# Executar um modelo com a API

Continue na mesma sessão do Bash e no mesmo diretório de trabalho do [início rápido](/pt/browser-rpa/quickstart). Primeiro, verifique se o cliente oferece suporte às operações usadas nesta página:

```bash
jq -e '.data.operations as $ops | ["validateWorkflow","startRun","getRun","listRunNodes","listRunArtifacts"] - $ops | length == 0' capabilities.json
```

Escolha um perfil de navegador Chromium. O ID do ambiente é o `envId` do perfil. Se você souber apenas o nome do perfil, encontre-o com `ml-cli env find --keyword <keyword>` ou com `POST /api/env/page` na [Local API do navegador](/pt/api-reference/browser/local-api) e resolva qualquer ambiguidade antes de executar. Para confirmar o tipo de navegador, verifique se `POST /api/env/detail` retorna `browserTypeId: 1`. Envie o ID como string. Posições em listas e portas de depuração não são IDs de perfil.

## 1. Fazer a pré-verificação da versão salva

Use o mesmo ID de modelo, a mesma versão, o mesmo ambiente e os mesmos parâmetros na pré-verificação e na execução. Informe o valor de cada parâmetro como `{kind:"json",value:...}`. Os parâmetros privados são enviados em texto simples, e os parâmetros de arquivo usam caminhos locais absolutos (um array para vários arquivos). Este exemplo não tem parâmetros privados. Continue somente quando o relatório de validação mostrar `valid: true` e estiver completo. Se o perfil estiver ocupado, aguarde até que a execução anterior libere o isolamento.

```bash
: "${RPA_ENVIRONMENT_ID:?Set the actual Chromium profile ID first}"
jq --arg env "$RPA_ENVIRONMENT_ID" '
  .data | {templateId:.id,version,environmentId:$env,
    parameters:{targetUrl:{kind:"json",value:"https://example.com"}}}
' created.json > start-run.json &&
jq '{purpose:"run",source:{kind:"template",templateId,version},
    environmentId,parameters}' start-run.json > validate-run.json &&
rpa_curl "$RPA_BASE_URL/validations" -H 'Content-Type: application/json' --data-binary @validate-run.json -o validation-run.json &&
jq '.data | {valid,issues,truncated,runtimeChecks}' validation-run.json &&
jq -e '.data.valid == true and .data.truncated == false' validation-run.json
```

## 2. Iniciar a execução

```bash
([ -s run.key ] || uuidgen > run.key) &&
rpa_curl "$RPA_BASE_URL/runs" \
  -H 'Content-Type: application/json' \
  -H "X-RPA-Catalog-Revision: $RPA_CATALOG_REVISION" \
  -H "Idempotency-Key: $(cat run.key)" \
  --data-binary @start-run.json -o started.json &&
RPA_RUN_ID="$(jq -er '.data.id' started.json)" &&
jq '.data | {id,status,template}' started.json
```

HTTP 202 significa que a execução foi registrada, e não que ela terminou. Guarde o ID da execução, a chave original e a revisão congelada do modelo. Um tempo limite de transporte não cancela a execução: use a [recuperação de solicitações](/pt/browser-rpa/local-api#recupera%C3%A7%C3%A3o) antes de enviar outra gravação.

## 3. Aguardar um estado final

```bash
for attempt in $(seq 1 100); do
  rpa_curl "$RPA_BASE_URL/runs/$RPA_RUN_ID" -o run-detail.json || break
  status="$(jq -r '.data.run.status' run-detail.json)"
  echo "status: $status"
  case "$status" in
    success|failed|cancelled|stopped|missed) break ;;
    queued) sleep 5 ;;
    *) sleep 3 ;;
  esac
done
```

O loop verifica uma execução ativa a cada 3 segundos e uma execução na fila a cada 5 segundos, e desiste após 100 verificações. Os estados ativos são `queued`, `preparing`, `running` e `cancel_requested`. Os estados finais são `success`, `failed`, `cancelled`, `stopped` e `missed`. Mantenha o total de solicitações de observação em até 40 por minuto e respeite o `Retry-After` em respostas 429 ou 503.

## 4. Ler o resultado

```bash
jq '.data | {status:.run.status,hasNodeErrors:.run.hasNodeErrors,
             isolation:.run.isolation,outputs:.result.outputs,error:.result.error}' run-detail.json &&
rpa_curl "$RPA_BASE_URL/runs/$RPA_RUN_ID/nodes?page=1&pageSize=20" -o run-nodes.json &&
rpa_curl "$RPA_BASE_URL/runs/$RPA_RUN_ID/artifacts" -o run-artifacts.json
```

O exemplo retorna `outputs.result: "https://example.com/"`. Verifique `data.run.hasNodeErrors`, `data.run.isolation.state` e também `data.result.outputs` e `data.result.error`: uma execução pode ser bem-sucedida mesmo que alguns nós tenham falhado e sido ignorados.

Os registros de execução dos nós são paginados. Enquanto a execução estiver ativa, leia a partir da página 1 a cada passagem e mescle os registros por `items[].id`. Depois que a execução atingir um estado final, leia todas as páginas sem filtro de status. O endpoint de artefatos retorna apenas metadados. Oculte as informações sensíveis da saída antes de compartilhá-la.

O cancelamento é uma solicitação: continue verificando o estado final real e o estado de isolamento. Não reinicie automaticamente quando o resultado for incerto ou o ambiente ainda estiver em quarentena. Para mais detalhes, consulte [Obter detalhes da execução](/pt/browser-rpa/api/get-run), [Listar execuções de nós](/pt/browser-rpa/api/list-run-nodes) e [Observação de execuções e recuperação de solicitações](/pt/browser-rpa/api/observation).