cURL · API de try-on virtuel
API de try-on virtuel avec cURL
En une phrase
Exportez PHOTTA_API_KEY, envoyez un POST à https://api.photta.app/api/v1/api/v1/tryon/apparel avec le corps JSON documenté, capturez l'ID de génération, puis effectuez une boucle de GET sur /api/v1/tryon/apparel/{id} toutes les 3 secondes jusqu'à ce que data.status soit completed. Associez avec jq pour extraire l'URL de sortie.
- Délai typique: 1.5–4 min
- Crédits: 5 crédits en 2K · 6 crédits en 4K
- Traitement: asynchrone, polling
- Limites: 600 requêtes/min
- Authentification: Clé Bearer
Chaque chiffre sur cette page provient de la documentation de l'API Photta · vérifié
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")En un coup d'œil
En un coup d'œil
- Endpoint
- POST /api/v1/tryon/apparel
- Authentification
- Clé API Bearer
- Traitement
- Asynchrone — interrogez l'endpoint de statut par polling
- Délai typique
- 1.5–4 min
- Crédits
- 5 crédits en 2K · 6 crédits en 4K
- Rapports d'aspect
- 3:4 · 1:1 · 4:3 · 9:16 · 16:9
- Limites d'entrée
- Jusqu'à 10 Mo par image ; JPEG, PNG, WebP
- Idempotent
- Non
Comment ça fonctionne
Cinq étapes dans le shell, zéro dépendance au-delà de curl et jq.
Étape 1
Inscrivez-vous et générez une clé
Rendez-vous sur ai.photta.app, ouvrez l'onglet Developers, cliquez sur Generate API key. Les clés de production commencent par `photta_live_`.
Étape 2
Exporter la clé
Ajoutez `export PHOTTA_API_KEY="photta_live_xxx"` dans votre profil shell ou dans un fichier `.envrc` afin que chaque appel curl ultérieur la récupère automatiquement.
curl --version # macOS, Linux, WSL and Windows 10+ ship it export PHOTTA_API_KEY="photta_live_xxxxx"Étape 3
Définir l'URL de base
`export PHOTTA_BASE_URL="https://api.photta.app/api/v1"` permet de garder les commandes curl concises.
export PHOTTA_BASE_URL="https://api.photta.app/api/v1" export AUTH_HEADER="Authorization: Bearer $PHOTTA_API_KEY"Étape 4
Soumettre et effectuer le polling
Envoyez un POST à `$PHOTTA_BASE_URL/api/v1/tryon/apparel` pour obtenir un ID, puis bouclez avec `curl $PHOTTA_BASE_URL/api/v1/tryon/apparel/{id}` toutes les 3 secondes. Passez la réponse dans jq pour extraire proprement `.data.status`.
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'Étape 5
Persister le résultat
Quand le job est terminé, extrayez `.data.output_url` avec jq et récupérez les octets avec `curl -o` vers le stockage local — prêt pour l'étape suivante de votre pipeline.
Erreurs
- 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.
case "$STATUS_CODE" in
402) echo "insufficient_credits_error — top up before retrying" ;;
429) echo "rate_limit_error — wait the Retry-After seconds (30 by default)" ;;
4??) echo "$BODY" | jq '.error.type, .error.message' ;;
5??) echo "api_error — retry with backoff" ;;
esacLimites
- 600 requêtes par minute par clé API (Fenêtre fixe ; la limite est identique sur tous les forfaits)
- Une 429 renvoie Retry-After: 30 secondes
- Jusqu'à 10 Mo par image
- Formats: JPEG, PNG, WebP
- Lots simultanés par forfait: Free 1 · Hobby 2 · Seller 3 · Brand 4 · Studio 6
- Polling uniquement — l'API n'envoie aucun webhook.
Pourquoi cURL reste le moyen le plus rapide de vérifier une API
- Zéro installation — cURL est fourni par défaut avec tous les OS majeurs
- S'associe à jq pour les pipelines scriptés (CI, cron, hooks shell)
- Le moyen le plus rapide de smoke-tester un endpoint avant de l'intégrer dans le code
- Chaque commande de cette page se colle directement dans n'importe quel shell POSIX
Ce qu'il ne fait pas
- La boucle de polling bloque le terminal — passez à Node ou Python pour des workers parallèles
- Le polling est le seul signal de complétion ; l'API n'envoie pas de webhooks
- Les utilisateurs de l'invite de commandes Windows doivent utiliser WSL ou le curl.exe de PowerShell
Questions fréquentes des développeurs
Existe-t-il un outil CLI Photta ?
Pas encore — mais cURL associé à un wrapper bash de quinze lignes couvre la majorité des besoins. La documentation privilégie les exemples cURL d'abord car chaque langage peut exécuter un sous-processus, et le shell est le dénominateur commun dans les pipelines CI.
Ai-je besoin de jq pour utiliser l'API ?
Pas obligatoirement — mais les pipelines scriptés sont bien plus simples avec. jq vous permet d'extraire `.data.id`, `.data.status` et `.data.output_url` de la réponse JSON sans la parser à la main. Installez-le avec `brew install jq` sur macOS ou `apt install jq` sur Debian/Ubuntu.
Comment s'authentifier avec curl ?
Ajoutez `-H "Authorization: Bearer $PHOTTA_API_KEY"` à chaque requête. Conservez la clé dans une variable d'environnement, ne l'insérez jamais en dur dans un script versionné. `curl --oauth2-bearer` fonctionne aussi, mais la forme avec header explicite est plus lisible dans la documentation et les logs.
Puis-je utiliser des scripts basés sur curl en production ?
Pour des rattrapages par lots ponctuels et des tâches cron, oui — des milliers d'équipes livrent des backfills de catalogue de cette façon. Pour une application pérenne, un vrai langage est généralement préférable pour bénéficier d'une gestion propre des erreurs, des retries et de l'observabilité. Les exemples curl de cette page restent valables même après avoir basculé vers Node ou Python ; la structure de la requête est identique.
Comment effectuer le polling depuis une boucle bash ?
Utilisez `for i in $(seq 1 120); do … ; sleep 3; done` en plaçant la vérification du statut dans le corps de la boucle. Interrompez dès que `.data.status` vaut `completed` ou `failed`. L'exemple de code sur cette page montre le pattern exact, y compris une limite supérieure stricte pour éviter qu'un job bloqué n'immobilise le script indéfiniment.
Comment lire les réponses d'erreur avec curl ?
Utilisez `curl -w "\n%{http_code}"` pour capturer le code de statut HTTP aux côtés du corps JSON. Effectuez vos branchements sur le statut : 402 pour des credits insuffisants, 429 pour le rate limit (respectez la valeur de Retry-After), 5xx pour les erreurs serveur temporaires. Le corps de l'erreur contient toujours les champs `error.code` et `error.message`.
Pages associées
Node.js
API de try-on virtuel en Node.js
Appelez aPI de try-on virtuel de Photta depuis un backend Node.js avec fetch natif. Aucun SDK requis : stockez votre clé, soumettez le job, récupérez le résultat par polling.
LirePython
API de try-on virtuel en Python
Appelez aPI de try-on virtuel de Photta en Python avec la bibliothèque requests. Un wrapper de trente lignes, compatible asynchrone via httpx, fonctionnant dans Django, FastAPI et Celery.
LireFonctionnalités
API de try-on virtuel pour les vêtements
API REST qui positionne des vêtements sur des mannequins générés par IA. Traitement asynchrone, génération en 1.5–4 minutes, 5 crédits en 2K, 6 en 4K. Exemples en cURL, Node.js et Python.
LireDévelopper
Intégrez une fonctionnalité de try-on virtuel à votre application
Guide d'implémentation de bout en bout pour intégrer le try-on virtuel avec l'API Photta : upload, soumission, polling via un worker, rendu du résultat. Architecture TypeScript + server-only.
LireDévelopper
Ajouter le virtual try-on à une application iOS ou Android
Comment ajouter le virtual try-on IA à une application native iOS ou Android avec l'API Photta : ne livrez jamais la clé sur l'appareil, passez par un proxy sur votre backend, répliquez l'état des jobs.
LireDémarrage rapide
Première image Photta en moins de cinq minutes.
Inscrivez-vous, générez une clé d'API, lancez votre premier appel cURL, effectuez le polling jusqu'à la complétion, persistez le résultat. Cinq étapes documentées de bout en bout.
LireRéférence
Tarification de l'API Photta
Le coût en credits de chaque endpoint de l’API Photta en 2K et 4K, le fonctionnement de la facturation et des remboursements, et les endpoints gratuits. Aucun prix monétaire par image.
Lire
Chaque chiffre sur cette page provient de la documentation de l'API Photta · vérifié
Testez l'API en cinq minutes
Générez une clé d'API Photta, collez le snippet cURL ci-dessus, et vous obtiendrez votre première photo portée sur modèle avant même que le café ait fini de couler.
- 1.5–4 min
- 5 crédits en 2K · 6 crédits en 4K
- asynchrone, polling
- 600 requêtes/min
- Clé Bearer