> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fire.rest/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Pon tu integración con Fire a funcionar end to end — recibir eventos e inyectar órdenes.

Esta guía te lleva por los pasos mínimos para tener una integración funcionando con Fire: recibir eventos de orden a través de un Integration Flow e inyectar órdenes vía la API REST.

## Prerrequisitos

* Credenciales de API desde el dashboard de Fire (consulta [Autenticación](/es/authentication))
* Un endpoint HTTPS accesible públicamente
* Acceso al dashboard en **Settings → Integration Flows**

## Paso 1: Configurar un Integration Flow

En el dashboard de Fire, ve a **Settings → Integration Flows → New flow**, luego:

* **Trigger:** elige `order.completed`
* **Scope:** account, vendor y opcionalmente tiendas específicas
* **Nodo HTTP:** agrega uno y configura
  * Método: `POST`
  * URL: tu endpoint HTTPS
  * Headers: `Content-Type: application/json` (más cualquier header de auth — Bearer token / API key)
  * Body: pega el template canónico de ejemplo que el dashboard incluye (produce `{ event, data, _meta }`)
* **Activa** el flow

Para un walkthrough de 10 minutos con detalle paso a paso, consulta [Manejar eventos de orden](/es/guides/handle-order-events).

<Tip>
  Durante el desarrollo puedes usar una herramienta como [ngrok](https://ngrok.com) para exponer un servidor local a internet. Pega la URL HTTPS de ngrok como URL del nodo HTTP del flow.
</Tip>

## Paso 2: Identificadores de canal y servicio para órdenes

Si inyectas órdenes, los objetos `channel` y `service` necesitan valores `uid` de Fire (y campos relacionados). Obtén esos identificadores desde los payloads de webhooks de publicación — por ejemplo [`channel.updated`](/es/webhook-reference/channel-updated) y eventos relacionados — o desde la configuración de integración y canales que gestionas en el panel de Fire (consulta [Integraciones de agregadores](/es/configuration/backoffice-integrations)).

## Paso 3: Manejar el evento

Tu endpoint recibirá peticiones `POST` desde tu flow cada vez que una orden se complete. La forma del body es la que el template del body de tu flow renderiza. Con el template canónico, eso es:

```json theme={null}
{
  "event": {
    "id": "0d6e8a1c-1e7a-4b4f-8a3a-74ab0e9a9b21",
    "type": "order.completed",
    "createdAt": "2026-05-06T01:22:59.902Z"
  },
  "data": {
    "orderId": "21ec1f6c-c301-4528-b999-7836c1d21c6c",
    "orderCode": "OC-br-001",
    "status": "COMPLETED",
    "paymentStatus": "SUCCEEDED",
    "store": { /* ... */ },
    "client": { /* ... */ },
    "payments": { /* ... */ },
    "orderLines": [ /* ... */ ],
    "fulfillment": { /* ... */ }
  },
  "_meta": { "executionId": "...", "flowId": "...", "attempt": "1" }
}
```

Un handler mínimo:

```js theme={null}
import express from "express";

const app = express();
const seen = new Map(); // reemplaza por Redis/DB en producción

app.post("/fire/events", express.json(), async (req, res) => {
  const { event, data } = req.body ?? {};
  if (!event?.id) return res.status(400).end();

  // 1. Confirma rápido (Fire hace timeout a los 30s)
  res.status(200).end();

  // 2. Deduplica por event.id
  if (seen.has(event.id)) return;
  seen.set(event.id, Date.now());

  // 3. Despacha por type
  switch (event.type) {
    case "order.completed":      return onOrderCompleted(data);
    case "order.cancelled":      return onOrderCancelled(data);
    case "order.invoiced": return onFiscalAuthorized(data);
    case "order.reversed":  return onFiscalCancelled(data);
  }
});

app.listen(8080);
```

Consulta [`order.completed`](/es/events/order-completed) para la referencia campo por campo del payload.

## Paso 4: Inyectar órdenes

Cuando tu sistema recibe una orden (de un agregador o cualquier otra fuente), inyéctala en Fire.

```http theme={null}
POST /v1/orders
Authorization: Bearer <tu_api_key>
Content-Type: application/json

{
  "channelId": "channel_uber",
  "externalOrderId": "uber_order_xyz",
  "...": "ver la referencia completa"
}
```

Una vez que la orden alcance `status=COMPLETED` y `paymentStatus=SUCCEEDED`, tu flow se dispara y tu handler corre. Si la orden se cancela después, recibirás `order.cancelled`.

Consulta [Inyectar orden](/es/api-reference/orders) para la referencia completa del payload.

## Paso 5: Agregar eventos fiscales (solo Brasil)

Si operas en Brasil y tienes emisión fiscal habilitada para una tienda, agrega un segundo flow con trigger `order.invoiced` (y otro con `order.reversed`) — mismo endpoint HTTPS, mismo template — para recibir el contexto del documento fiscal.

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Manejar eventos de orden" icon="bolt" href="/es/guides/handle-order-events">
    Walkthrough detallado con auth e idempotencia.
  </Card>

  <Card title="Resumen de eventos" icon="bell" href="/es/events/overview">
    Envelope, headers, reintentos, dedup.
  </Card>

  <Card title="Referencia order.completed" icon="receipt" href="/es/events/order-completed">
    Esquema de payload completo con los bloques fiscales BR.
  </Card>

  <Card title="Referencia API" icon="code" href="/es/api-reference/introduction">
    Inyectar órdenes y llamar endpoints autenticados.
  </Card>
</CardGroup>