cURL · Workflows API
Workflows API med cURL
I en mening
Exportera PHOTTA_API_KEY, gör en POST till https://api.photta.app/api/v1/api/v1/workflows/{workflow_id} med den dokumenterade JSON-bodyn, fånga generations-ID:t och kör sedan en GET-loop mot /api/v1/workflows/generations/{id} var 3:e sekund tills data.status är completed. Kombinera med jq för att extrahera utdata-URL:en.
- Typisk tid: 20–60 sec / image
- Credits: 4 credits vid 2K · 5 credits vid 4K
- Bearbetning: asynkron, polling
- Gränser: 600 requests/min
- Autentisering: Bearer-nyckel
Varje siffra på den här sidan kommer från Photter API-dokumentationen · kontrollerad
RESPONSE=$(curl -s -X POST https://api.photta.app/api/v1/workflows/jewelry-studio-shot \
-H "Authorization: Bearer $PHOTTA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"images": {
"jewelry": [
"https://cdn.yourstore.com/products/gold-ring.jpg"
]
},
"options": {
"jewelryLighting": "dramatic",
"backdrop": "dark"
},
"user_text": "hero shot, ring angled slightly toward the camera",
"num_images": 2,
"aspect_ratio": "3:4",
"resolution": "2K"
}')
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/workflows/generations/$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/workflows/jewelry-studio-shot", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.PHOTTA_API_KEY}`, "Content-Type": "application/json" },
body: JSON.stringify({
"images": {
"jewelry": [
"https://cdn.yourstore.com/products/gold-ring.jpg"
]
},
"options": {
"jewelryLighting": "dramatic",
"backdrop": "dark"
},
"user_text": "hero shot, ring angled slightly toward the camera",
"num_images": 2,
"aspect_ratio": "3:4",
"resolution": "2K"
}),
});
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/workflows/generations/${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/workflows/jewelry-studio-shot",
headers={"Authorization": f"Bearer {os.environ['PHOTTA_API_KEY']}"},
json={
"images": {
"jewelry": [
"https://cdn.yourstore.com/products/gold-ring.jpg"
]
},
"options": {
"jewelryLighting": "dramatic",
"backdrop": "dark"
},
"user_text": "hero shot, ring angled slightly toward the camera",
"num_images": 2,
"aspect_ratio": "3:4",
"resolution": "2K"
},
)
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/workflows/generations/{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")I korthet
I korthet
- Endpoint
- POST /api/v1/workflows/{workflow_id}
- Autentisering
- Bearer API-nyckel
- Bearbetning
- Asynkron — polla status-endpointen
- Typisk tid
- 20–60 sec / image
- Credits
- 4 credits vid 2K · 5 credits vid 4K
- Bildförhållanden
- 3:4 · 1:1 · 4:3 · 9:16 · 16:9
- Indatagränser
- Upp till 10 MB per bild; JPEG, PNG, WebP
- Idempotent
- Nej
Hur det fungerar
Fem steg i skalet, noll beroenden utöver curl och jq.
Steg 1
Registrera dig och generera en nyckel
Gå till ai.photta.app, öppna fliken Developers och klicka på Generate API key. Live-nycklar börjar med `photta_live_`.
Steg 2
Exportera nyckeln
Lägg `export PHOTTA_API_KEY="photta_live_xxx"` i din skalprofil eller en `.envrc`-fil så att alla efterföljande curl-anrop plockar upp den automatiskt.
curl --version # macOS, Linux, WSL and Windows 10+ ship it export PHOTTA_API_KEY="photta_live_xxxxx"Steg 3
Lås bas-URL:en
`export PHOTTA_BASE_URL="https://api.photta.app/api/v1"` håller curl-kommandona korta.
export PHOTTA_BASE_URL="https://api.photta.app/api/v1" export AUTH_HEADER="Authorization: Bearer $PHOTTA_API_KEY"Steg 4
Skicka och polla
POST:a till `$PHOTTA_BASE_URL/api/v1/workflows/{workflow_id}` för att få ett ID, och loopa sedan `curl $PHOTTA_BASE_URL/api/v1/workflows/generations/{id}` var 3:e sekund. Pipe:a svaret till jq för att snyggt extrahera `.data.status`.
RESPONSE=$(curl -s -X POST https://api.photta.app/api/v1/workflows/jewelry-studio-shot \ -H "Authorization: Bearer $PHOTTA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "images": { "jewelry": [ "https://cdn.yourstore.com/products/gold-ring.jpg" ] }, "options": { "jewelryLighting": "dramatic", "backdrop": "dark" }, "user_text": "hero shot, ring angled slightly toward the camera", "num_images": 2, "aspect_ratio": "3:4", "resolution": "2K" }') 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/workflows/generations/$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'Steg 5
Spara resultatet
När jobbet är klart hämtar du ut `.data.output_url` med jq och kör `curl -o` för att spara bytsen till lokal lagring — redo för nästa steg i din pipeline.
Fel
- 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" ;;
esacGränser
- 600 anrop per minut per API-nyckel (Fast fönster; gränsen är densamma på alla planer)
- En 429 innehåller Retry-After: 30 sekunder
- Upp till 10 MB per bild
- Format: JPEG, PNG, WebP
- Samtidiga batcher per plan: Free 1 · Hobby 2 · Seller 3 · Brand 4 · Studio 6
- Endast polling — API:et skickar inga webhooks.
Varför cURL fortfarande är det snabbaste sättet att verifiera ett API
- Noll installation — cURL skeppas med alla större operativsystem
- Passar ihop med jq för skriptade pipelines (CI, cron, shell hooks)
- Det snabbaste sättet att röktesta en endpoint innan den kopplas in i kod
- Varje kommando på denna sida kan klistras in i valfritt POSIX-skal
Vad det inte gör
- Polling-loopen blockerar terminalen — gå över till Node eller Python för parallella workers
- Polling är den enda signalen på att jobbet är klart; API:et skickar inga webhooks
- Användare av Windows Kommandotolken bör köra WSL eller PowerShells curl.exe
Vanliga utvecklarfrågor
Finns det ett Photta CLI-verktyg?
Inte än — men cURL plus en bash-wrapper på femton rader tar dig nästan hela vägen. Dokumentationen prioriterar cURL-exempel eftersom alla språk kan köra en underprocess, och skalet är den gemensamma nämnaren i CI-pipelines.
Måste jag använda jq för att använda API:et?
Inte strikt — men skriptade pipelines blir mycket enklare med det. Med jq kan du plocka ut `.data.id`, `.data.status` och `.data.output_url` ur JSON-svaret utan att parsa det för hand. Installera med `brew install jq` på macOS eller `apt install jq` på Debian/Ubuntu.
Hur autentiserar jag med curl?
Lägg till `-H "Authorization: Bearer $PHOTTA_API_KEY"` i varje anrop. Spara nyckeln i en miljövariabel, hårdkoda den aldrig i ett skript du checkar in. `curl --oauth2-bearer` fungerar också, men den explicita header-formen är tydligare i dokumentation och loggar.
Kan jag använda curl-baserade skript i produktion?
För enstaka batch-backfills och cron-jobb, ja — tusentals team kör katalog-backfills på detta sätt. För en långlivad applikation är ett riktigt språk oftast bättre eftersom du får ordentlig felhantering, retries och observerbarhet. Curl-exemplen på den här sidan förblir relevanta även efter att du porterat till Node eller Python; anropets struktur är densamma.
Hur pollar jag från en bash-loop?
Använd `for i in $(seq 1 120); do … ; sleep 3; done` med statuskontrollen inuti loopen. Avbryt när `.data.status` är `completed` eller `failed`. Kodexemplet på den här sidan visar det exakta mönstret, inklusive en hård övre gräns så att ett jobb som fastnat inte hänger skriptet för alltid.
Hur läser jag felsvar i curl?
Använd `curl -w "\n%{http_code}"` för att fånga HTTP-statuskoden tillsammans med JSON-bodyn. Förgrena logiken baserat på status: 402 för otillräckliga credits, 429 för rate limits (respektera Retry-After-värdet), 5xx för transienta serverfel. Felfältet i bodyn innehåller alltid fälten `error.code` och `error.message`.
Relaterade sidor
Node.js
Workflows API i Node.js
Anropa Phottas workflows API från en Node.js-backend med inbyggd fetch. Ingen SDK krävs: lagra din nyckel, skicka in jobbet, polla efter resultatet.
LäsPython
Workflows API i Python
Anropa Phottas workflows API i Python med requests-biblioteket. Wrapper på trettio rader, async-vänlig via httpx, fungerar i Django, FastAPI och Celery.
LäsFunktioner
Workflows API ett anrop, en förinställning
Kör färdiga scenmallar mot dina produktfoton. Katalogen deklarerar sina egna bildplatser och alternativ, så en enda integration täcker varje förinställning.
LäsBygg
Bygg en tjänst för AI-produktfotografering
En grundares playbook för att återförsälja Phottas virtuella try-on-API som en white-label-SaaS: klientnycklar, batch-fanout, fakturering per credit, SLA-realiteter.
LäsSnabbstart
Första Photta-bilden på under fem minuter.
Skapa konto, generera en API-nyckel, kör ditt första cURL-anrop, polla tills det är klart, spara resultatet. Fem steg, dokumenterade från början till slut.
LäsReferens
Photta API-prissättning
Vad varje Photta API-endpoint kostar i credits i 2K och 4K, hur debitering och återbetalning fungerar, samt vilka endpoints som är gratis. Inget fast pris i pengar per bild.
Läs
Varje siffra på den här sidan kommer från Photter API-dokumentationen · kontrollerad
Testa API:et på fem minuter
Generera en Photta API-nyckel, klistra in cURL-kodfragmentet ovan, och du har din första bild på en modell innan kaffet har bryggts klart.
- 20–60 sec / image
- 4 credits vid 2K · 5 credits vid 4K
- asynkron, polling
- 600 requests/min
- Bearer-nyckel