Python · Virtuelle Try-on-API
Virtuelle Try-on-API in Python
In aller Kürze
Installieren Sie requests, laden Sie PHOTTA_API_KEY aus env, schreiben Sie einen photta()-Wrapper, der den Bearer-Key sendet und bei Nicht-2xx-Antworten einen typisierten PhottaError wirft, senden Sie dann einen POST-Request an /api/v1/tryon/apparel und pollen Sie /api/v1/tryon/apparel/{id} alle 3 Sekunden, bis der status completed ist.
- Typische Dauer: 1.5–4 min
- Credits: 5 Credits bei 2K · 6 Credits bei 4K
- Verarbeitung: asynchron, Polling
- Limits: 600 Anfragen/Min.
- Authentifizierung: Bearer-Key
Jeder Zahlenwert auf dieser Seite stammt aus der Photta-API-Dokumentation · geprüft
RESPONSE=$(curl -s -X POST https://api.photta.app/api/v1/tryon/apparel \
-H "Authorization: Bearer $PHOTTA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"product_type": "top",
"product_images": [
"https://cdn.yourstore.com/products/shirt-front.jpg"
],
"product_back_image": "https://cdn.yourstore.com/products/shirt-back.jpg",
"product_category": "t_shirt",
"mannequin_id": "mnk_f3a9b1",
"pose_id": "pose_c2d4e5",
"background": "https://cdn.yourstore.com/backgrounds/studio-loft.jpg",
"lock_background": true,
"resolution": "2K",
"aspect_ratio": "3:4",
"body_size": "M",
"expression": "neutral",
"user_instruction": "Keep the collar pattern crisp and centered."
}')
ID=$(echo "$RESPONSE" | jq -r '.data.id')
# $ID is data.id from the POST response. Poll every 3 seconds until status is "completed" or "failed".
for i in $(seq 1 120); do
RESULT=$(curl -s "https://api.photta.app/api/v1/tryon/apparel/$ID" -H "Authorization: Bearer $PHOTTA_API_KEY")
STATUS=$(echo "$RESULT" | jq -r '.data.status')
[ "$STATUS" = "completed" ] && break
[ "$STATUS" = "failed" ] && echo "generation failed" && exit 1
sleep 3
done
echo "$RESULT" | jq -r '.data.output_url'const res = await fetch("https://api.photta.app/api/v1/tryon/apparel", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.PHOTTA_API_KEY}`, "Content-Type": "application/json" },
body: JSON.stringify({
"product_type": "top",
"product_images": [
"https://cdn.yourstore.com/products/shirt-front.jpg"
],
"product_back_image": "https://cdn.yourstore.com/products/shirt-back.jpg",
"product_category": "t_shirt",
"mannequin_id": "mnk_f3a9b1",
"pose_id": "pose_c2d4e5",
"background": "https://cdn.yourstore.com/backgrounds/studio-loft.jpg",
"lock_background": true,
"resolution": "2K",
"aspect_ratio": "3:4",
"body_size": "M",
"expression": "neutral",
"user_instruction": "Keep the collar pattern crisp and centered."
}),
});
const { data } = await res.json(); // data.id, data.status
async function waitFor(id) {
for (let attempt = 0; attempt < 120; attempt++) {
const res = await fetch(`https://api.photta.app/api/v1/tryon/apparel/${id}`, { headers: { Authorization: `Bearer ${process.env.PHOTTA_API_KEY}` } });
const { data } = await res.json();
if (data.status === "completed") return data.output_url;
if (data.status === "failed") throw new Error(data.error_message ?? "generation failed");
await new Promise((r) => setTimeout(r, 3000));
}
throw new Error("timed out after 6 minutes");
}import os, requests
res = requests.post(
"https://api.photta.app/api/v1/tryon/apparel",
headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"},
json={
"product_type": "top",
"product_images": [
"https://cdn.yourstore.com/products/shirt-front.jpg"
],
"product_back_image": "https://cdn.yourstore.com/products/shirt-back.jpg",
"product_category": "t_shirt",
"mannequin_id": "mnk_f3a9b1",
"pose_id": "pose_c2d4e5",
"background": "https://cdn.yourstore.com/backgrounds/studio-loft.jpg",
"lock_background": True,
"resolution": "2K",
"aspect_ratio": "3:4",
"body_size": "M",
"expression": "neutral",
"user_instruction": "Keep the collar pattern crisp and centered."
},
)
data = res.json()["data"] # data["id"], data["status"]
import time
def wait_for(job_id):
for _ in range(120):
res = requests.get(f"https://api.photta.app/api/v1/tryon/apparel/{job_id}", headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"})
data = res.json()["data"]
if data["status"] == "completed":
return data["output_url"]
if data["status"] == "failed":
raise RuntimeError(data.get("error_message", "generation failed"))
time.sleep(3)
raise TimeoutError("timed out after 6 minutes")Auf einen Blick
Auf einen Blick
- Endpoint
- POST /api/v1/tryon/apparel
- Authentifizierung
- Bearer-API-Schlüssel
- Verarbeitung
- Asynchron — Polling über den Status-Endpoint
- Typische Dauer
- 1.5–4 min
- Credits
- 5 Credits bei 2K · 6 Credits bei 4K
- Seitenverhältnisse
- 3:4 · 1:1 · 4:3 · 9:16 · 16:9
- Eingabelimits
- Bis zu 10 MB pro Bild; JPEG, PNG, WebP
- Idempotent
- Nein
Funktionsweise
Fünf Schritte, null Photta-spezifische Abhängigkeiten — requests deckt alles ab.
Schritt 1
Registrieren und einen Key generieren
Derselbe Weg wie in jeder anderen Sprache: ai.photta.app → Developers → Generate API key. Keys beginnen mit `photta_live_` und funktionieren über alle Photta-Capabilities hinweg.
Schritt 2
Den Key aus env laden
Setzen Sie `PHOTTA_API_KEY` in der Umgebung und lesen Sie ihn über `os.environ` aus. Laden Sie ihn in FastAPI oder Django einmalig beim Start in ein Settings-Modul. Betteln Sie den Key nicht im Quellcode oder der öffentlichen Git-Historie ein.
python3 -m pip install requests export PHOTTA_API_KEY="photta_live_xxxxx"Schritt 3
Einen requests-Wrapper schreiben
Eine 30-zeilige `photta_request()`-Funktion übernimmt die Basis-URL, den Authorization-Header, die JSON-Serialisierung und die Fehlerübersetzung. Das ist die einzige Abstraktion, die Sie brauchen, bis das Python-SDK erscheint.
# photta.py — one helper for every endpoint import os, requests BASE = "https://api.photta.app/api/v1" class PhottaError(Exception): def __init__(self, status, error, retry_after=None): super().__init__(error.get("message", "request failed")) self.status, self.type, self.retry_after = status, error.get("type"), retry_after def photta(method, path, **kwargs): res = requests.request(method, BASE + path, headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"}, timeout=30, **kwargs) body = res.json() if not res.ok: raise PhottaError(res.status_code, body.get("error", {}), res.headers.get("Retry-After")) return bodySchritt 4
Übermitteln und pollen
Senden Sie einen POST an `/api/v1/tryon/apparel`, um eine Generierungs-ID zu erhalten, und pollen Sie anschließend `/api/v1/tryon/apparel/{id}` in einem 3-Sekunden-Intervall. Verteilen Sie die Polling-Schleife in Celery oder RQ über mehrere Tasks, damit ein minutenlanger Job keinen Worker blockiert.
import os, requests res = requests.post( "https://api.photta.app/api/v1/tryon/apparel", headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"}, json={ "product_type": "top", "product_images": [ "https://cdn.yourstore.com/products/shirt-front.jpg" ], "product_back_image": "https://cdn.yourstore.com/products/shirt-back.jpg", "product_category": "t_shirt", "mannequin_id": "mnk_f3a9b1", "pose_id": "pose_c2d4e5", "background": "https://cdn.yourstore.com/backgrounds/studio-loft.jpg", "lock_background": True, "resolution": "2K", "aspect_ratio": "3:4", "body_size": "M", "expression": "neutral", "user_instruction": "Keep the collar pattern crisp and centered." }, ) data = res.json()["data"] # data["id"], data["status"] import time def wait_for(job_id): for _ in range(120): res = requests.get(f"https://api.photta.app/api/v1/tryon/apparel/{job_id}", headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"}) data = res.json()["data"] if data["status"] == "completed": return data["output_url"] if data["status"] == "failed": raise RuntimeError(data.get("error_message", "generation failed")) time.sleep(3) raise TimeoutError("timed out after 6 minutes")Schritt 5
Ergebnis persistieren
Die Payload nach Abschluss enthält `output_url` und `thumbnail_url`. Laden Sie die Bytes in Ihren eigenen Object Storage herunter — S3, GCS, Cloudflare R2 —, damit Ihr Produkt für das langfristige Rendering nicht an das CDN von Photta gebunden ist.
Fehler
- 400
invalid_request_error - The request is malformed or contains invalid parameters.
- 401
authentication_error - The API key is missing, invalid, or expired.
- 402
insufficient_credits_error - Your account does not have enough credits.
- 404
not_found_error - The requested resource does not exist.
- 409
conflict_error - The request conflicts with current state — e.g. your concurrent-batch cap is reached.
- 429
rate_limit_error - Too many requests. Slow down and retry.Retry-After: 30
- 500
api_error - An internal server error occurred. Retry later.
try:
photta("POST", "/tryon/apparel", json={
"product_type": "top",
"product_images": [
"https://cdn.yourstore.com/products/shirt-front.jpg"
],
"product_back_image": "https://cdn.yourstore.com/products/shirt-back.jpg",
"product_category": "t_shirt",
"mannequin_id": "mnk_f3a9b1",
"pose_id": "pose_c2d4e5",
"background": "https://cdn.yourstore.com/backgrounds/studio-loft.jpg",
"lock_background": True,
"resolution": "2K",
"aspect_ratio": "3:4",
"body_size": "M",
"expression": "neutral",
"user_instruction": "Keep the collar pattern crisp and centered."
})
except PhottaError as e:
if e.status == 402:
print("insufficient_credits_error: top up before retrying")
elif e.status == 429:
time.sleep(int(e.retry_after or 30))
else:
raiseLimits
- 600 Anfragen pro Minute pro API-Schlüssel (Festes Zeitfenster; das Limit ist in jedem Tarif identisch)
- Ein 429 enthält Retry-After: 30 Sekunden
- Bis zu 10 MB pro Bild
- Formate: JPEG, PNG, WebP
- Gleichzeitige Batches pro Tarif: Free 1 · Hobby 2 · Seller 3 · Brand 4 · Studio 6
- Nur Polling — die API sendet keine Webhooks.
Warum requests heute die richtige Wahl ist
- Keine Photta-spezifische Abhängigkeit — requests ist bereits in den meisten Python-Projekten vorhanden
- Funktioniert überall, wo Python läuft: Django, FastAPI, Flask, Celery-Worker, Lambda, Skripte
- Der Client-Wrapper umfasst etwa 30 Zeilen — fügen Sie ihn in photta.py ein und machen Sie weiter
- Lässt sich über httpx mit asyncio kombinieren, wenn Sie parallele Übermittlungen benötigen
Was es nicht tut
- Noch kein offizielles Photta-Python-Paket — REST mit requests ist das dokumentierte Muster
- Polling ist das einzige Fertigstellungssignal; die API sendet keine Webhooks
- Nur Bearer-Key; es gibt keinen OAuth-Client-Credentials-Flow
Häufige Fragen von Entwicklern
Gibt es ein offizielles Photta-Python-SDK?
Noch nicht. Der unterstützte Integrationspfad ist die requests-Bibliothek (synchron) oder httpx (asynchron) — beide erfordern lediglich einen schlanken Wrapper, und der Wrapper auf dieser Seite funktioniert für jede Funktion.
Welche Python-Versionen werden unterstützt?
Python 3.9 und höher. Der Wrapper verwendet Type Hints, f-Strings und die `str | None`-Syntax, was ab 3.10 einwandfrei funktioniert. Unter 3.9 ersetzen Sie `str | None` durch `Optional[str]`. requests selbst unterstützt offiziell 3.8+, aber 3.9+ ist das praktische Minimum für moderne Photta-Projekte.
Sollte ich requests oder httpx verwenden?
requests, wenn Sie eine Handvoll sequenzieller Aufrufe durchführen — es ist einfacher und bereits in den meisten Codebasen vorhanden. httpx, wenn Sie asynchrone Nebenläufigkeit (parallele Übermittlungen, Bulk-Backfills) oder HTTP/2 benötigen. Der Wrapper ist in beiden Fällen winzig; tauschen Sie `requests.request` gegen `httpx.Client().request` aus und der restliche Code bleibt identisch.
Kann ich es über Django aufrufen?
Ja. Legen Sie den Wrapper in `services/photta.py` ab und importieren Sie ihn aus einem View oder einem Celery-Task. Rufen Sie die API bei langen Jobs nicht innerhalb eines synchronen Request-Handlers auf — übermitteln Sie den Job aus dem View, geben Sie die Generierungs-ID zurück und pollen Sie über einen Hintergrund-Task oder einen Channels-Consumer.
Wie polle ich über einen Celery-Worker?
Übermitteln Sie den Job über einen Task und planen Sie dann einen Folge-Task (über `apply_async(countdown=3)`), der einmal pollt und sich selbst neu einplant, bis der Job abgeschlossen ist oder ein Max-Retries-Schwellenwert erreicht wird. Das hält Worker frei und verhindert lang laufende Tasks, die Autoscaler stören.
Wie signalisiert die API Fehler?
Nicht-2xx-Antworten enthalten einen JSON-Body mit einem `error`-Objekt: `type`, `code`, `message`, sowie `param` bei 400ern und `retry_after` bei 429ern. Der Wrapper auf dieser Seite löst einen `PhottaError` aus, der all diese Angaben enthält, sodass Ihre Aufrufer nach Statuscode verzweigen können, ohne den Body selbst parsen zu müssen.
Verwandte Seiten
Node.js
Virtuelle Try-on-API in Node.js
Rufen Sie Phottas virtuelle Try-on-API von einem Node.js-Backend mit nativem fetch auf. Kein SDK erforderlich: Key speichern, Job absenden, Ergebnis pollen.
LesencURL
Virtuelle Try-on-API mit cURL
Rufen Sie Phottas virtuelle Try-on-API direkt über die Shell mit cURL auf. Übermitteln, pollen, herunterladen — jedes Snippet lässt sich für skriptbasierte Pipelines mit jq kombinieren.
LesenFunktionen
Virtuelle Try-on-API für Apparel
REST-API zur Platzierung von Bekleidung auf KI-Mannequins. Asynchron, 1.5–4 Minuten Generierungsdauer, 5 credits bei 2K, 6 bei 4K. Beispiele für cURL, Node.js und Python.
LesenBuild
Baue ein Virtual-Try-On-Feature für deine App
End-to-End-Rezept für die Implementierung eines Virtual-Try-On-Features mit der Photta API: Upload, Absenden, Polling über einen Worker, Rendern des Ergebnisses. TypeScript + Server-only-Muster.
LesenBuild
Virtuelles Try-On zu einer iOS- oder Android-App hinzufügen
So fügen Sie virtuelles KI-Try-On zu einer nativen iOS- oder Android-App mit der Photta-API hinzu: Liefern Sie den Key niemals an das Endgerät aus, leiten Sie Anfragen über Ihr Backend weiter und spiegeln Sie den Job-Status.
LesenSchnellstart
Erstes Photta-Bild in unter 5 Minuten.
Registrieren, API-Key generieren, ersten cURL-Aufruf ausführen, pollen bis zum Abschluss, Ergebnis persistieren. 5 Schritte, durchgängig dokumentiert.
LesenReferenz
Photta-API-Preise
Was jeder Photta API-Endpoint in Credits bei 2K und 4K kostet, wie Abrechnung und Erstattungen funktionieren und welche Endpoints kostenlos sind. Kein Geldpreis pro Bild.
Lesen
Jeder Zahlenwert auf dieser Seite stammt aus der Photta-API-Dokumentation · geprüft
Testen Sie die API in fünf Minuten
Generieren Sie einen Photta-API-Schlüssel, fügen Sie das obige cURL-Snippet ein, und Sie erhalten Ihr erstes Bild am Model, noch bevor der Kaffee fertig gebrüht ist.
- 1.5–4 min
- 5 Credits bei 2K · 6 Credits bei 4K
- asynchron, Polling
- 600 Anfragen/Min.
- Bearer-Key