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

> ## Agent Instructions
> Reconify's API reference is read-only for customer data. Do not invent endpoints or authentication behavior beyond the OpenAPI contract.
> The public OpenAPI document contains only the documented external /v2 contract.

# Quickstart

> One key, one event, one read-back.

Monitoring starts the moment your first event lands. In the next five minutes you create a
key, send one `payment.succeeded` event, and read it back to confirm Reconify stored it.

## 1. Get an API key

Your organization's keys live in **Dashboard → Settings → API Keys**. A `write` key covers
this quickstart, and [Authentication](/reference/api/authentication) covers the scopes in
full.

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
export RECONIFY_API_KEY="rk_your_key_here"
```

## 2. Install an SDK

The API is plain JSON over HTTPS, so cURL needs no installation. The official SDKs add
typed requests, structured errors, and cursor helpers.

<CodeGroup>
  ```bash npm theme={"theme":{"light":"github-light","dark":"github-dark"}}
  npm install @reconifyhq/sdk
  ```

  ```bash pip theme={"theme":{"light":"github-light","dark":"github-dark"}}
  pip install reconify-python
  ```

  ```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
  # Nothing to install.
  ```
</CodeGroup>

## 3. Send one event

An event carries the flow it belongs to, its type, the reference that identifies the
operation, and the entity the money is moving toward. Monetary event types also carry an
amount and a currency.

<CodeGroup>
  ```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
  curl --fail-with-body -sS -X POST "https://api.reconifyhq.com/v2/events" \
    -H "Authorization: Bearer $RECONIFY_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"events":[{"id":"evt_01J3Y0M8VJQ5W1R3E4J4K7N8W5","flow":"payment_to_wallet","type":"payment.succeeded","occurred_at":"2026-01-01T12:00:00Z","amount":"150.00","currency":"USD","reference":"order-123","entity_id":"wallet_123"}]}'
  ```

  ```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  import { ReconifyClient } from "@reconifyhq/sdk";

  const client = new ReconifyClient({ apiKey: process.env.RECONIFY_API_KEY });

  const result = await client.ingestion.ingestMonitoringEvents({
    body: {
      events: [
        {
          id: "evt_01J3Y0M8VJQ5W1R3E4J4K7N8W5",
          flow: "payment_to_wallet",
          type: "payment.succeeded",
          occurred_at: "2026-01-01T12:00:00Z",
          amount: "150.00",
          currency: "USD",
          reference: "order-123",
          entity_id: "wallet_123",
        },
      ],
    },
  });
  ```

  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  from reconify import Reconify
  from reconify.models import MonitoringBatchRequest, MonitoringEvent

  with Reconify() as client:
      result = client.ingestion.ingest_monitoring_events(
          MonitoringBatchRequest(
              events=[
                  MonitoringEvent(
                      id="evt_01J3Y0M8VJQ5W1R3E4J4K7N8W5",
                      flow="payment_to_wallet",
                      type="payment.succeeded",
                      occurred_at="2026-01-01T12:00:00Z",
                      amount="150.00",
                      currency="USD",
                      reference="order-123",
                      entity_id="wallet_123",
                  )
              ]
          )
      )
  ```
</CodeGroup>

The response carries one result per submitted event, in the order you sent them:

```json theme={"theme":{"light":"github-light","dark":"github-dark"}}
{
  "results": [{ "index": 0, "status": "accepted" }]
}
```

An `accepted` result means Reconify stored the event as evidence. It says nothing yet
about whether the operation passed evaluation.

<Note>
  Reconify has no sandbox. Every event you send here becomes real evidence in the
  organization behind your key, so a throwaway reference such as `order-123` keeps your
  first test out of production data.
</Note>

## 4. Read it back

A `read` or `admin` key confirms what arrived. The cURL examples across these guides read
it from `RECONIFY_READ_KEY`:

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
export RECONIFY_READ_KEY="rk_your_read_key_here"
```

<CodeGroup>
  ```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
  curl --fail-with-body -sS "https://api.reconifyhq.com/v2/events?limit=1" \
    -H "Authorization: Bearer $RECONIFY_READ_KEY"
  ```

  ```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  const page = await client.events.listEvents({ query: { limit: 1 } });
  ```

  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  page = client.events.list_events(limit=1)
  ```
</CodeGroup>

The record comes back with a processing `status`. `received` means Reconify holds the
durable receipt, `published` means the event entered asynchronous processing, and
`processed` means evaluation finished. Evaluation runs in seconds, so a first read often
shows `received`.

## What comes next

The next two pages turn one event into a monitored flow.

<Columns cols={2}>
  <Card title="Send events" icon="send" href="/guides/api-integration">
    Batches, item results, and safe retries.
  </Card>

  <Card title="Monitoring model" icon="activity" href="/concepts/overview">
    Flows, operations, deadlines, and findings.
  </Card>
</Columns>