cURL · API de Provador Virtual

API de Provador Virtual com cURL

A maneira mais rápida de entender qualquer API é chamá-la pelo shell. As docs da Photta são cURL-first por design — tudo nesta página roda em um único terminal, sem necessidade de Node ou Python.

Em uma frase

Exporte `PHOTTA_API_KEY`, envie um POST para `https://ai.photta.app/api/v1/tryon/apparel` com o corpo JSON correto, capture o ID de geração e, em seguida, faça um loop de `curl … /tryon/apparel/:id` a cada 3 segundos até que `data.status` mude para `completed` — tipicamente entre 1.5 e 4 minutos. Use com `jq` para extrair a URL de saída da resposta final.

Atualizado · 2026-04-19

Sua primeira requisição

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

O que esperar

Typical completion

1–3min

2K / 4K credits

4 / 6

Styles

2

Batch-ready

yes

Como funciona

API de Provador Virtual com cURL

Cinco passos no shell, zero dependências além de curl e jq.

  1. 01

    Passo 1

    Cadastre-se e gere uma chave

    Acesse ai.photta.app, abra a aba de Desenvolvedores e clique em Gerar chave de API. Chaves live começam com `photta_live_`.

  2. 02

    Passo 2

    Exporte a chave

    Coloque `export PHOTTA_API_KEY="photta_live_xxx"` no seu profile do shell ou em um arquivo `.envrc` para que cada chamada de curl subsequente a utilize automaticamente.

  3. 03

    Passo 3

    Fixe a URL base

    `export PHOTTA_BASE_URL="https://ai.photta.app/api/v1"` mantém os comandos curl curtos e facilita a troca por uma URL de sandbox quando estiver disponível.

  4. 04

    Passo 4

    Enviar e poll

    Envie um POST para `$PHOTTA_BASE_URL/tryon/apparel` para obter um ID e, em seguida, faça um loop de `curl $PHOTTA_BASE_URL/tryon/apparel/$ID` a cada 3 segundos. Direcione a resposta para o jq para extrair `.data.status` de forma limpa.

  5. 05

    Passo 5

    Persista o resultado

    Quando o job terminar, extraia `.data.output_url` com jq e use `curl -o` para salvar os bytes no storage local — pronto para o próximo passo do seu pipeline.

Código, ponta a ponta

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

Por que esse formato

Por que o cURL ainda é a forma mais rápida de verificar uma API

  • 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

O que não faz

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

Perguntas que outros desenvolvedores fazem

Questions other developers ask

Existe uma ferramenta de CLI da Photta?+

Ainda não — mas cURL mais um wrapper bash de quinze linhas resolve a maioria dos casos. As docs priorizam exemplos em cURL porque qualquer linguagem pode rodar um subprocesso, e o shell é o denominador comum em pipelines de CI.

Preciso do jq para usar a API?+

Não estritamente — mas pipelines em script são muito mais fáceis com ele. O jq permite extrair `.data.id`, `.data.status` e `.data.output_url` da resposta JSON sem precisar parsear manualmente. Instale com `brew install jq` no macOS ou `apt install jq` no Debian/Ubuntu.

Como autentico via curl?+

Adicione `-H "Authorization: Bearer $PHOTTA_API_KEY"` a cada requisição. Mantenha a chave em uma variável de ambiente, nunca a coloque diretamente em um script que você vá comitar. `curl --oauth2-bearer` também funciona, mas o formato de header explícito é mais claro em documentações e logs.

Posso usar scripts baseados em curl em produção?+

Para backfills pontuais em lote e cron jobs, sim — milhares de equipes processam catálogos dessa forma. Para uma aplicação de longa duração, uma linguagem real costuma ser melhor por oferecer tratamento de erros adequado, retentativas e observabilidade. Os exemplos em curl nesta página permanecem precisos mesmo após você portar para Node ou Python; o formato da requisição é o mesmo.

Como faço poll a partir de um loop em bash?+

Use `for i in $(seq 1 120); do … ; sleep 3; done` com a verificação de status no corpo do loop. Saia do loop quando `.data.status` for `completed` ou `failed`. O exemplo de código nesta página mostra o padrão exato, incluindo um limite superior rígido para que um job travado não prenda o script para sempre.

Como leio as respostas de erro no curl?+

Use `curl -w "\n%{http_code}"` para capturar o código de status HTTP junto com o corpo JSON. Faça o desvio com base no status: 402 para créditos insuficientes, 429 para rate limits (respeite o valor de Retry-After), 5xx para erros transientes do servidor. O corpo do erro sempre possui os campos `error.code` e `error.message`.

cURL · API de Provador Virtual

Criar conta e obter chave de API

Exporte `PHOTTA_API_KEY`, envie um POST para `https://ai.photta.app/api/v1/tryon/apparel` com o corpo JSON correto, capture o ID de geração e, em seguida, faça um loop de `curl … /tryon/apparel/:id` a cada 3 segundos até que `data.status` mude para `completed` — tipicamente entre 1.5 e 4 minutos. Use com `jq` para extrair a URL de saída da resposta final.

API de Provador Virtual com cURL — Photta | Photta