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

# Quickstart

> Send your first email and observe the event it produces. About a minute end-to-end.

By the end of this page you will have:

1. An identity with at least one warmed mailbox under it.
2. An API key.
3. A successful send to your own address.
4. The `email.sent` event for that send, retrieved from the events stream.

<Steps>
  <Step title="Create an identity">
    Sign in at [inboxbase.ai/app](https://inboxbase.ai/app) and create an identity. You
    pick a brand (the identity handle, e.g. `alice.acme@inboxbase.ai`) and a tier
    (which sets the daily send cap). Provisioning is asynchronous — it
    takes a few minutes the first time while we register domains and
    warm up the initial mailboxes.

    <Tip>
      The handle is what you'll put in URLs. It's not the address
      recipients see — they see whichever rotated mailbox we picked for
      that send.
    </Tip>
  </Step>

  <Step title="Mint an API key">
    Go to **Developers → API keys**, click **Create key**, name it,
    copy the value somewhere safe. The key starts with `sk_live_…`.
    Keys are org-scoped: one key can act as any identity in your org. The
    identity is always identified in the URL path.

    <Warning>
      The key is shown once. Lose it and you mint a new one. There's no
      "show again" button.
    </Warning>
  </Step>

  <Step title="Send an email">
    Send a message to your own address so you can confirm delivery.

    <CodeGroup>
      ```bash cURL theme={null}
      curl https://api.inboxbase.ai/v1/identities/alice.acme@inboxbase.ai/send \
        -H "Authorization: Bearer sk_live_..." \
        -H "Content-Type: application/json" \
        -d '{
          "to":      "you@your-personal-domain.com",
          "subject": "Hello from 12m",
          "text":    "Reply to this and I will see it on the events stream."
        }'
      ```

      ```js Node theme={null}
      const res = await fetch(
        "https://api.inboxbase.ai/v1/identities/alice.acme@inboxbase.ai/send",
        {
          method: "POST",
          headers: {
            Authorization: `Bearer ${process.env.TWELVEM_KEY}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            to: "you@your-personal-domain.com",
            subject: "Hello from 12m",
            text: "Reply to this and I will see it on the events stream.",
          }),
        },
      );
      console.log(await res.json());
      ```

      ```python Python theme={null}
      import os, requests
      r = requests.post(
          "https://api.inboxbase.ai/v1/identities/alice.acme@inboxbase.ai/send",
          headers={"Authorization": f"Bearer {os.environ['TWELVEM_KEY']}"},
          json={
              "to": "you@your-personal-domain.com",
              "subject": "Hello from 12m",
              "text": "Reply to this and I will see it on the events stream.",
          },
      )
      print(r.json())
      ```
    </CodeGroup>

    You should see a `202` with a body that includes the `convId` of
    the new conversation, and the `account` field telling you which
    rotated mailbox we used.
  </Step>

  <Step title="Read the event">
    Every send writes an `email.sent` event to a per-identity log. You can
    pull from that log with a cursor — useful for development, agents,
    and any environment where you can't expose a public webhook URL.

    ```bash theme={null}
    curl "https://api.inboxbase.ai/v1/identities/alice.acme@inboxbase.ai/events?since=0&limit=10" \
      -H "Authorization: Bearer sk_live_..."
    ```

    The event you just produced will be in there with `type: "email.sent"`,
    the `convId` from your send response, and a monotonic `seq`. That `seq`
    is the cursor for the next call.
  </Step>
</Steps>

## What's next

You have the loop. The rest of the docs explain how to use it well.

<CardGroup cols={2}>
  <Card title="No-reply timers" icon="clock" href="/guides/no-reply-timers">
    The primitive that turns "send and wait" into "send and react."
    Cheaper than running your own scheduler.
  </Card>

  <Card title="Reacting to replies" icon="reply" href="/guides/reacting-to-replies">
    Push (webhooks) or pull (events stream) — same data, two
    delivery modes. Pick one or both.
  </Card>

  <Card title="Live thread list" icon="bars-staggered" href="/guides/live-thread-list">
    The pattern for an inbox view that updates in real time without
    you maintaining a copy of our state.
  </Card>

  <Card title="Building a sequencer" icon="diagram-project" href="/guides/sequencer">
    Multi-step cold outbound on top of `/send` and the events stream.
    Your DB stays small.
  </Card>
</CardGroup>