cURL · Virtual Try-On API

Virtual Try-On API met cURL

De snelste manier om een API te begrijpen, is door deze aan te roepen vanuit de shell. De documentatie van Photta is bewust cURL-first — alles op deze pagina draait in één terminal, geen Node of Python nodig.

In één zin

Exporteer `PHOTTA_API_KEY`, doe een POST naar `https://ai.photta.app/api/v1/tryon/apparel` met de juiste JSON-body, leg het generatie-ID vast en loop vervolgens elke 3 seconden `curl … /tryon/apparel/:id` totdat `data.status` verspringt naar `completed` — meestal binnen 1.5 tot 4 minuten. Gebruik `jq` om de output-URL uit de uiteindelijke response te halen.

Bijgewerkt · 2026-04-19

Je eerste verzoek

cURLNode.jsPythoncURL
# Submit a try-on job. The API returns 202 Accepted + a generation ID.
JOB=$(curl -s -X POST "$PHOTTA_BASE_URL/tryon/apparel" \
  -H "$AUTH_HEADER" \
  -H "Content-Type: application/json" \
  -d '{
    "product_type": "dress",
    "product_images": ["https://example.com/dress.jpg"],
    "mannequin_id": "mnq_athena_ts",
    "pose_id": "pose_standing_front",
    "resolution": "2K",
    "aspect_ratio": "3:4"
  }')

ID=$(echo "$JOB" | jq -r '.data.id')
echo "Generation $ID queued"

# Poll every 3 seconds until the job completes (max 6 minutes).
for i in $(seq 1 120); do
  RESULT=$(curl -s "$PHOTTA_BASE_URL/tryon/apparel/$ID" -H "$AUTH_HEADER")
  STATUS=$(echo "$RESULT" | jq -r '.data.status')
  if [ "$STATUS" = "completed" ]; then
    echo "$RESULT" | jq -r '.data.output_url'
    break
  fi
  if [ "$STATUS" = "failed" ]; then
    echo "$RESULT" | jq -r '.data.error_message' >&2
    exit 1
  fi
  sleep 3
done

Wat je kunt verwachten

Typical completion

1.5–4min

2K / 4K credits

5 / 7

Jewelry types

4

Close-up mannequins

built-in

Hoe het werkt

Virtual Try-On API met cURL

Vijf shell-stappen, nul dependencies behalve curl en jq.

  1. 01

    Stap 1

    Meld je aan en genereer een sleutel

    Ga naar ai.photta.app, open het Developers-tabblad en klik op Generate API key. Live sleutels beginnen met `photta_live_`.

  2. 02

    Stap 2

    Exporteer de sleutel

    Zet `export PHOTTA_API_KEY="photta_live_xxx"` in je shell-profiel of een `.envrc`-bestand, zodat elke volgende curl-call deze automatisch oppikt.

  3. 03

    Stap 3

    Zet de basis-URL vast

    `export PHOTTA_BASE_URL="https://ai.photta.app/api/v1"` houdt de curl-commando's kort en maakt het eenvoudig om te wisselen naar een sandbox-URL zodra deze beschikbaar is.

  4. 04

    Stap 4

    Indienen en pollen

    POST naar `$PHOTTA_BASE_URL/tryon/apparel` om een ID te krijgen, en loop vervolgens `curl $PHOTTA_BASE_URL/tryon/apparel/$ID` elke 3 seconden. Sluis de response door naar jq om `.data.status` schoon te extraheren.

  5. 05

    Stap 5

    Sla het resultaat op

    Wanneer de taak is voltooid, haal je `.data.output_url` op met jq en gebruik je `curl -o` om de bytes naar lokale opslag te schrijven — klaar voor de volgende stap in je pipeline.

Code, van begin tot eind

Copy, paste, done.

Four snippets — install prerequisites, wrap the REST call, submit + poll, then handle the errors that actually happen in production.

01cURL is already installed on macOS, Linux, WSL and modern Windows
bash
# Verify curl is available
curl --version

# Export your API key so the rest of the calls can reference it
export PHOTTA_API_KEY="photta_live_xxxxx"
02Set the base URL + auth header once
bash
# Pin the base URL in a shell variable so every call is a one-liner.
export PHOTTA_BASE_URL="https://ai.photta.app/api/v1"

# Reusable auth header — every request needs it.
AUTH_HEADER="Authorization: Bearer $PHOTTA_API_KEY"
03Submit and poll in one script
bash
# Submit a try-on job. The API returns 202 Accepted + a generation ID.
JOB=$(curl -s -X POST "$PHOTTA_BASE_URL/tryon/apparel" \
  -H "$AUTH_HEADER" \
  -H "Content-Type: application/json" \
  -d '{
    "product_type": "dress",
    "product_images": ["https://example.com/dress.jpg"],
    "mannequin_id": "mnq_athena_ts",
    "pose_id": "pose_standing_front",
    "resolution": "2K",
    "aspect_ratio": "3:4"
  }')

ID=$(echo "$JOB" | jq -r '.data.id')
echo "Generation $ID queued"

# Poll every 3 seconds until the job completes (max 6 minutes).
for i in $(seq 1 120); do
  RESULT=$(curl -s "$PHOTTA_BASE_URL/tryon/apparel/$ID" -H "$AUTH_HEADER")
  STATUS=$(echo "$RESULT" | jq -r '.data.status')
  if [ "$STATUS" = "completed" ]; then
    echo "$RESULT" | jq -r '.data.output_url'
    break
  fi
  if [ "$STATUS" = "failed" ]; then
    echo "$RESULT" | jq -r '.data.error_message' >&2
    exit 1
  fi
  sleep 3
done
04Read the status code + error body instead of silently failing
bash
# -w pulls out the HTTP status without polluting the JSON body.
RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "$PHOTTA_BASE_URL/tryon/apparel" \
  -H "$AUTH_HEADER" \
  -H "Content-Type: application/json" \
  -d '{ "product_type": "dress" }')

BODY=$(echo "$RESPONSE" | sed '$d')
STATUS=$(echo "$RESPONSE" | tail -1)

case "$STATUS" in
  200|202)
    echo "$BODY" | jq '.data' ;;
  402)
    echo "Out of credits" ; echo "$BODY" | jq '.error' ;;
  429)
    RETRY=$(echo "$BODY" | jq -r '.error.retry_after')
    echo "Rate limited — retry in ${RETRY}s" ;;
  *)
    echo "Error $STATUS" ; echo "$BODY" | jq '.error' ;;
esac

Waarom deze vorm

Waarom cURL nog steeds de snelste manier is om een API te verifiëren

  • Zero install — cURL ships with every major OS
  • Pairs with `jq` for scripted pipelines (CI, cron, bash hooks)
  • Ideal for smoke-testing endpoints before wiring them into code
  • All code in this page copy-pastes into any POSIX shell

Wat het niet doet

Honest caveats

  • cURL's polling loop blocks your terminal — move to Node/Python for parallel workers
  • No streaming parser for the result; you fetch the final URL when the job is done
  • Windows Command Prompt users should run WSL or PowerShell's curl.exe wrapper

Vragen die andere developers stellen

Questions other developers ask

Is er een Photta CLI-tool?+

Nog niet — maar cURL plus een bash-wrapper van vijftien regels brengt je een heel eind. De documentatie geeft prioriteit aan cURL-first voorbeelden omdat elke taal 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 — maar gescripte pipelines zijn er veel eenvoudiger mee. Met jq kun je `.data.id`, `.data.status` en `.data.output_url` uit de JSON-response halen zonder deze handmatig te hoeven parsen. 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, zet hem nooit direct in een script dat je in versiebeheer zet. `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 cronjobs: ja — duizenden teams voeren catalogus-backfills op deze manier uit. Voor een langlopende applicatie is een echte programmeertaal meestal beter, omdat je dan beschikt over fatsoenlijke foutafhandeling, retries en observability. De curl-voorbeelden op deze pagina blijven accuraat, zelfs nadat je ze hebt overgezet naar Node of Python; de structuur van het verzoek is hetzelfde.

Hoe poll ik vanuit een bash loop?+

Gebruik `for i in $(seq 1 120); do … ; sleep 3; done` met de statuscontrole in de loop. Stop wanneer `.data.status` op `completed` of `failed` staat. Het codevoorbeeld op deze pagina toont het exacte patroon, inclusief een harde bovengrens zodat een vastgelopen taak het script niet oneindig blokkeert.

Hoe lees ik foutmeldingen in curl?+

Gebruik `curl -w "\n%{http_code}"` om de HTTP-statuscode samen met de JSON-body vast te leggen. Differentieer op basis van de status: 402 voor onvoldoende credits, 429 voor rate limits (volg de Retry-After waarde), 5xx voor tijdelijke serverfouten. De error body bevat altijd een `error.code` en `error.message` veld.

cURL · Virtual Try-On API

Maak een account aan en ontvang een API-sleutel

Exporteer `PHOTTA_API_KEY`, doe een POST naar `https://ai.photta.app/api/v1/tryon/apparel` met de juiste JSON-body, leg het generatie-ID vast en loop vervolgens elke 3 seconden `curl … /tryon/apparel/:id` totdat `data.status` verspringt naar `completed` — meestal binnen 1.5 tot 4 minuten. Gebruik `jq` om de output-URL uit de uiteindelijke response te halen.

Virtual Try-On API met cURL — Photta | Photta