cURL · Sieraden try-on API
Sieraden try-on API met cURL
In één zin
Exporteer PHOTTA_API_KEY, verstuur een POST naar https://api.photta.app/api/v1/api/v1/tryon/jewelry met de gedocumenteerde JSON-body, sla het generatie-ID op en voer vervolgens elke 3 seconden een GET-lus uit op /api/v1/tryon/jewelry/{id} totdat data.status completed is. Combineer met jq om de output-URL te extraheren.
- Typische duur: 1.5–4 min
- Credits: 5 credits bij 2K · 6 credits bij 4K
- Verwerking: async, polling
- Limieten: 600 requests/min
- Authenticatie: Bearer key
Elk getal op deze pagina is afkomstig uit de Photta-API-documentatie · gecontroleerd
RESPONSE=$(curl -s -X POST https://api.photta.app/api/v1/tryon/jewelry \
-H "Authorization: Bearer $PHOTTA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"jewelry_image": "https://cdn.yourstore.com/products/gold-necklace.jpg",
"jewelry_type": "necklace",
"mannequin_id": "mnk_j9k1l2",
"background": "soft window light on dark velvet",
"resolution": "2K",
"aspect_ratio": "3:4",
"user_instruction": "Make the pendant 10% smaller."
}')
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/jewelry/$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/jewelry", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.PHOTTA_API_KEY}`, "Content-Type": "application/json" },
body: JSON.stringify({
"jewelry_image": "https://cdn.yourstore.com/products/gold-necklace.jpg",
"jewelry_type": "necklace",
"mannequin_id": "mnk_j9k1l2",
"background": "soft window light on dark velvet",
"resolution": "2K",
"aspect_ratio": "3:4",
"user_instruction": "Make the pendant 10% smaller."
}),
});
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/jewelry/${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/jewelry",
headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"},
json={
"jewelry_image": "https://cdn.yourstore.com/products/gold-necklace.jpg",
"jewelry_type": "necklace",
"mannequin_id": "mnk_j9k1l2",
"background": "soft window light on dark velvet",
"resolution": "2K",
"aspect_ratio": "3:4",
"user_instruction": "Make the pendant 10% smaller."
},
)
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/jewelry/{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")In één oogopslag
In één oogopslag
- Endpoint
- POST /api/v1/tryon/jewelry
- Authenticatie
- Bearer API key
- Verwerking
- Asynchroon — poll het status-endpoint
- Typische duur
- 1.5–4 min
- Credits
- 5 credits bij 2K · 6 credits bij 4K
- Beeldverhoudingen
- 3:4 · 1:1 · 4:3 · 9:16 · 16:9
- Invoerlimieten
- Tot 10 MB per afbeelding; JPEG, PNG, WebP
- Idempotent
- Nee
Hoe het werkt
Vijf shell-stappen, nul afhankelijkheden buiten curl en jq.
Stap 1
Meld je aan en genereer een sleutel
Ga naar ai.photta.app, open het tabblad Developers en klik op Generate API key. Live sleutels beginnen met `photta_live_`.
Stap 2
Exporteer de sleutel
Plaats `export PHOTTA_API_KEY="photta_live_xxx"` in je shell-profiel of een `.envrc`-bestand, zodat elke volgende curl-aanroep deze automatisch oppakt.
curl --version # macOS, Linux, WSL and Windows 10+ ship it export PHOTTA_API_KEY="photta_live_xxxxx"Stap 3
Zet de basis-URL vast
`export PHOTTA_BASE_URL="https://api.photta.app/api/v1"` houdt de curl-opdrachten beknopt.
export PHOTTA_BASE_URL="https://api.photta.app/api/v1" export AUTH_HEADER="Authorization: Bearer $PHOTTA_API_KEY"Stap 4
Verzenden en pollen
POST naar `$PHOTTA_BASE_URL/api/v1/tryon/jewelry` om een ID te verkrijgen, en loop vervolgens elke 3 seconden `curl $PHOTTA_BASE_URL/api/v1/tryon/jewelry/{id}`. Pipe het antwoord naar jq om `.data.status` schoon te extraheren.
RESPONSE=$(curl -s -X POST https://api.photta.app/api/v1/tryon/jewelry \ -H "Authorization: Bearer $PHOTTA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "jewelry_image": "https://cdn.yourstore.com/products/gold-necklace.jpg", "jewelry_type": "necklace", "mannequin_id": "mnk_j9k1l2", "background": "soft window light on dark velvet", "resolution": "2K", "aspect_ratio": "3:4", "user_instruction": "Make the pendant 10% smaller." }') 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/jewelry/$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'Stap 5
Sla het resultaat op
Wanneer de job is voltooid, haal je `.data.output_url` eruit met jq en `curl -o` je de bytes naar lokale opslag — klaar voor je volgende pipelinestap.
Errors
- 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" ;;
esacLimieten
- 600 verzoeken per minuut per API key (Vast venster; de limiet is identiek op elk abonnement)
- Een 429 bevat Retry-After: 30 seconden
- Tot 10 MB per afbeelding
- Formaten: JPEG, PNG, WebP
- Gelijktijdige batches per abonnement: Free 1 · Hobby 2 · Seller 3 · Brand 4 · Studio 6
- Uitsluitend polling — de API stuurt geen webhooks.
Waarom cURL nog steeds de snelste manier is om een API te verifiëren
- Geen installatie nodig — cURL wordt standaard meegeleverd met elk modern OS
- Combineert met jq voor gescripte pipelines (CI, cron, shell-hooks)
- De snelste manier om een endpoint te smoke-testen voordat je het in code integreert
- Elk commando op deze pagina kan direct in elke POSIX-shell worden geplakt
Wat het niet doet
- De polling-loop blokkeert de terminal — stap over naar Node of Python voor parallelle workers
- Polling is het enige signaal voor voltooiing; de API verstuurt geen webhooks
- Gebruikers van de Windows-opdrachtprompt moeten WSL of PowerShells curl.exe gebruiken
Veelgestelde vragen van developers
Is er een Photta CLI-tool?
Nog niet — maar met cURL en een bash-wrapper van vijftien regels kom je een heel eind. De documentatie geeft voorrang aan cURL-first voorbeelden omdat elke programmeertaal een subprocess kan draaien, en de shell de gemene deler is in CI-pipelines.
Heb ik jq nodig om de API te gebruiken?
Niet strikt noodzakelijk — maar gescripte pipelines zijn er wel veel eenvoudiger mee. Met jq haal je `.data.id`, `.data.status` en `.data.output_url` uit de JSON-respons zonder handmatige parsing. Installeer met `brew install jq` op macOS of `apt install jq` op Debian/Ubuntu.
Hoe authenticeer ik met curl?
Voeg `-H "Authorization: Bearer $PHOTTA_API_KEY"` toe aan elk verzoek. Bewaar de sleutel in een omgevingsvariabele, plaats deze nooit inline in een script dat je commit. `curl --oauth2-bearer` werkt ook, maar de expliciete header-vorm is duidelijker in documentatie en logs.
Kan ik op curl gebaseerde scripts in productie gebruiken?
Voor eenmalige batch-backfills en cron jobs wel — duizenden teams verwerken catalogus-backfills op deze manier. Voor een langlopende applicatie is een volwaardige taal meestal beter, omdat je degelijke foutafhandeling, retries en observability krijgt. De curl-voorbeelden op deze pagina blijven accuraat, zelfs nadat je ze naar Node of Python porteert; de structuur van het verzoek blijft hetzelfde.
Hoe poll ik vanuit een bash-loop?
Gebruik `for i in $(seq 1 120); do … ; sleep 3; done` met de statuscontrole in de body van de loop. Breek af zodra `.data.status` `completed` of `failed` is. Het codevoorbeeld op deze pagina toont het exacte patroon, inclusief een harde bovengrens zodat een vastgelopen job het script niet oneindig laat hangen.
Hoe lees ik foutmeldingen uit in curl?
Gebruik `curl -w "\n%{http_code}"` om de HTTP-statuscode samen met de JSON-body vast te leggen. Schakel op basis van de status: 402 voor onvoldoende credits, 429 voor rate limits (respecteer de Retry-After-waarde), 5xx voor tijdelijke serverfouten. De error-body bevat altijd een `error.code`- en `error.message`-veld.
Gerelateerde pagina's
Node.js
Sieraden try-on API in Node.js
Roep Photta's sieraden try-on API aan vanuit een Node.js-backend met native fetch. Geen SDK vereist: sla je sleutel op, verzend de taak, poll voor het resultaat.
LezenPython
Sieraden try-on API in Python
Roep Photta's sieraden try-on API aan in Python met de requests-bibliotheek. Een wrapper van dertig regels, async-vriendelijk via httpx, werkt in Django, FastAPI en Celery.
LezenMogelijkheden
Sieraden try-on API voor kettingen, ringen, armbanden en oorbellen
Plaats kettingen, ringen, armbanden en oorbellen op AI-modellen via REST. 5 credits bij 2K, ingebouwde close-up mannequins, reflectie-bewuste rendering uit de Photta-documentatie.
LezenBouwen
Bouw een AI-dienst voor productfotografie
Een playbook voor founders om de virtuele try-on API van Photta door te verkopen als een white-label SaaS: tenant-sleutels, batch-distributie, facturatie per credit en de realiteit rond SLA's.
LezenSnelstartgids
Eerste Photta-afbeelding in minder dan vijf minuten.
Registreer je, genereer een API-sleutel, voer je eerste cURL-call uit, poll totdat deze is voltooid, sla het resultaat op. Vijf stappen, end-to-end gedocumenteerd.
LezenReferentie
Photta API-prijzen
Wat elk Photta API-endpoint kost in credits op 2K en 4K, hoe facturering en restituties werken, en welke endpoints gratis zijn. Geen geldprijs per afbeelding.
Lezen
Elk getal op deze pagina is afkomstig uit de Photta-API-documentatie · gecontroleerd
Probeer de API in vijf minuten
Genereer een Photta API-sleutel, plak het bovenstaande cURL-fragment en je hebt je eerste afbeelding op een model voordat de koffie klaar is.
- 1.5–4 min
- 5 credits bij 2K · 6 credits bij 4K
- async, polling
- 600 requests/min
- Bearer key