> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/aprender/outras-linguagens/chamar-o-skail-de-qualquer-linguagem-por-rest.md).

# Chamar o skail de qualquer linguagem por REST

Trigger e fire por HTTP a partir de Node.js; o mesmo padrão vale para qualquer linguagem.

Os fluxos são escritos com o SDK, mas quem os inicia e quem os acorda pode ser qualquer sistema em qualquer linguagem, com HTTP puro. São dois `POST`: um para iniciar uma function, outro para disparar um evento. Esta página mostra os dois em Node.js; o padrão é o mesmo em Java, Python, PHP, Go ou em um shell script.

## O fluxo em C#, para referência

Uma function que valida, espera uma aprovação humana, chama uma API externa e espera a confirmação dela:

```csharp
public static class Eventos
{
    public const string AprovacaoSolicitacao = "APROVACAO_SOLICITACAO";
    public const string ConfirmacaoExterna   = "CONFIRMACAO_EXTERNA";
}

[SkailFunction]
public async SkailTask ProcessarSolicitacao(SolicitacaoRequest request)
{
    await ExecutarValidacao(request);                                        // command

    var aprovacao = SkailTask.WaitForEvent<AprovacaoRequest>(Eventos.AprovacaoSolicitacao, request.Id);
    var prazo     = SkailTask.Delay(TimeSpan.FromDays(3));
    if (await SkailTask.WhenAny(aprovacao, prazo) == prazo) { await RegistrarExpiracao(request.Id); return; }

    if (!(await aprovacao).Aprovado) return;

    var resultado = await ChamarApiExterna(request);                          // command, com retry

    var confirmacao      = SkailTask.WaitForEvent<ConfirmacaoExterna>(Eventos.ConfirmacaoExterna, resultado.TransacaoId);
    var prazoConfirmacao = SkailTask.Delay(TimeSpan.FromHours(24));
    if (await SkailTask.WhenAny(confirmacao, prazoConfirmacao) == prazoConfirmacao) { await RegistrarExpiracao(request.Id); return; }

    await RegistrarConclusao(request.Id, await confirmacao);                  // command
}
```

Três pontos de contato com o mundo de fora: o início (trigger), a aprovação (fire) e a confirmação da API externa (fire, disparado pelo endpoint que recebe o webhook dela).

## Iniciar a function: trigger

`POST {SKAIL_BASE_URL}/trigger/{workload}/{versao}/{funcao}/{id}`. O corpo é um array JSON com os argumentos da function, na ordem da assinatura, com os mesmos nomes de propriedade dos records C#. O `id` é o identificador da execução; use um id de negócio.

```typescript
const url = `${SKAIL_BASE_URL}/trigger/${WORKLOAD}/${VERSION}/ProcessarSolicitacao/${request.Id}`;

const res = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'skail-key': SKAIL_KEY,
    'Skail-namespace': SKAIL_NAMESPACE,
  },
  body: JSON.stringify([request]),
});
if (!res.ok) throw new Error(`trigger falhou: ${res.status}`);
```

`WORKLOAD` e `VERSION` são as duas partes de `SKAIL_WORKLOAD` da aplicação C# (`solicitacoes` e `v1.0.0`, por exemplo). Se o trigger falhar (rede, 429, 5xx), retente com backoff usando o mesmo `id`: a chamada que inicia a execução fica fora da durabilidade do skail.

## Acordar a function: fire

`POST {SKAIL_BASE_URL}/api/v1/fire/{eventName}/{instanceId}`. O corpo é o payload do evento, desserializado no tipo do `WaitForEvent<T>`, com os mesmos nomes de propriedade do record C#. Nome e instance id precisam ser idênticos aos usados na function.

A aprovação, disparada pelo BFF quando alguém clica em aprovar:

```typescript
const url = `${SKAIL_BASE_URL}/api/v1/fire/APROVACAO_SOLICITACAO/${request.Id}`;

const res = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'skail-key': SKAIL_KEY,
    'Skail-namespace': SKAIL_NAMESPACE,
  },
  body: JSON.stringify({ Aprovado: true, Observacao: 'ok' }),
});
if (!res.ok) throw new Error(`fire falhou: ${res.status}`);
```

A confirmação, disparada pelo endpoint que recebe o webhook da API externa:

```typescript
const url = `${SKAIL_BASE_URL}/api/v1/fire/CONFIRMACAO_EXTERNA/${transacaoId}`;

const res = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'skail-key': SKAIL_KEY,
    'Skail-namespace': SKAIL_NAMESPACE,
  },
  body: JSON.stringify(confirmacao),
});
if (!res.ok) throw new Error(`fire falhou: ${res.status}`);
```

Se o evento chegar antes de a function alcançar o `WaitForEvent`, ele é entregue quando a espera começar. Se o fire falhar (rede, 429, 5xx), retente com backoff, como no trigger: essa chamada também fica fora da durabilidade do skail.

## Em outras linguagens

É HTTP: dois `POST` com dois headers e um corpo JSON. Em Python, `requests.post(url, json=[request], headers={...})`. Em Java, `HttpClient` com `BodyPublishers.ofString`. Em PHP, `curl_init`. Em um pipeline, `curl`. A referência completa das duas rotas está em [POST /trigger](/construir/api-http/post-trigger-workload-versao-funcao-id.md) e [POST /api/v1/fire](/construir/api-http/post-api-v1-fire-eventname-instanceid.md).

## Próximos passos

[Autenticação e headers](/construir/api-http/autenticacao-e-headers.md) para chave, namespace e erros. [Como disparar uma função pela API HTTP](/construir/escrever-fluxos/como-disparar-uma-funcao-pela-api-http.md) para o padrão completo em C#, com retry. [SDK TypeScript e outras linguagens](/aprender/outras-linguagens/sdk-typescript-e-outras-linguagens.md) para o que existe além do REST.