# Email API for a new era.

Email APIs solved delivery, then developer experience. AI Inbx is built for what comes next: software that handles the conversation end to end, on its own.

[Get started](/signup)

One thread: an RFQ, an out-of-office, and a colleague answering from a different address — matched and categorised on the way in.

## Built for software that runs the conversation

### [Agentic first](/use-cases/ai-email-agent)

Every message arrives threaded, categorised and ready for an agent to act on.

### [Deliverability by default](/features/pacing)

Hours, pacing and opt-outs keep your domain trusted at any volume.

### [Built for platforms](/features/spaces)

A space per customer, with their domains, inboxes and rules.

Why AI Inbx

## Other email APIs deliver mail. AI Inbx understands it.

Marco replies instead of Dana, from his phone, with a new subject. Most email APIs: A new, unrelated thread. Your agent loses the history. AI Inbx: Same thread, in full.

Dana answers your four questions inside the quoted text. Most email APIs: You get “answers below.” The four answers are gone. AI Inbx: Every answer, under the question it answers.

An out-of-office bounces back. Most email APIs: It looks like a reply. Your agent answers a robot. AI Inbx: Tagged out\_of\_office. One if, and nothing wakes up.

The quote comes back as a scanned PDF. Most email APIs: A base64 blob. Your agent needs a parser and an OCR bill. AI Inbx: Already parsed. Markdown, ready for your agent.

Something wants to send at 02:47 on a Sunday. Most email APIs: It sends. Nobody human emails at 02:47. AI Inbx: Held. Out Monday 09:00, like a person sent it.

Your agent has 400 follow-ups ready at once. Most email APIs: It sends 400. Gmail throttles your domain for a week. AI Inbx: Capped per sender, per company. The rest waits its turn.

Someone replies “please stop emailing me”. Most email APIs: Nothing happens. You email them again. AI Inbx: Unsubscribed. From the words alone, no click.

Threading

## One conversation, however it comes back

You email Dana. Marco answers instead — new address, new subject, no headers. Same thread.

Reply text

## Every answer, wherever they typed it

Dana answers your four questions inside the quoted text, the way people actually reply. Most email APIs hand your agent “answers below.” The four answers went with the quote.

The same reply read three ways. As it arrived it is about 194 tokens, the four answers buried in the quoted text. Most email APIs cut at the first quote marker and keep about 6 tokens, "Hi Nora, answers below.", losing all four answers. AI Inbx keeps about 110 tokens: every answer under the question it answers, with the quoted conversation and the signature gone.

The same conversation six turns in, as an agent would be handed it: every body in full is 1,850 tokens, because each reply quotes the conversation again. Most email APIs' stripped text is 257 tokens but drops Dana's four answers. AI Inbx smart stripped is 299 tokens, a sixth of the full bodies, with nothing dropped.

Everywhere else that is a choice between what a thread costs and what is left in it. Here it is one field on every message: stripped\_text.

Categories

## Skip the noise

Out-of-office replies, receipts, newsletters. Every message arrives carrying what it is, so one line of yours decides whether it is worth waking your agent for.

Every message carries a category such as out of office, marketing, bounce, transactional or auto-reply, so one line, if (email.category !== "human") return, lets only 3 of the 8 messages in this example inbox wake your agent.

Attachments

## Every document arrives as text

Marco answers with a PDF. It is Markdown before the email is, and so is the spreadsheet under it — your agent is handed what the document says, not a file and a parsing problem.

Example: Quote-4471.pdf, a supplier's quote, arrives as Markdown: sender and recipient addresses, the quote heading and date, the line items as a Markdown table (item, quantity, price), the net, VAT and total, and the delivery and payment terms.

Sending hours

## Never email at 3am

Your agent runs at all hours. A company does not, and a Sunday 02:47 timestamp is how people tell the difference.

Set the hours you actually work. Anything your code sends outside them waits, and goes out the moment the window opens. Add a limit and the night’s backlog trickles out instead of landing at once.

Pacing

## Slow down, without stopping

Send too fast and mail providers mark your domain down for it. Write the caps you want — per sender, per company, across everything — and stack them. Every email clears all the ones that apply to it.

Suppressions

## Unsubscribe, handled

The link and the one-click header go on every send. And when someone just writes “please stop emailing me”, we read that too.

Six ways off your list

-   Unsubscribe link
-   One-click header
-   A reply saying stop
-   Hard bounce
-   Complaint
-   API

Mailboxes

## Gmail and Outlook, same everything

Connect Gmail and Outlook accounts and they are just more addresses. Same send call, same threads, categories, hours, pacing and webhooks as your domains — nothing in your code knows the difference.

await aiinbx.emails.send({
  from: "nora@gmail.com",
  to: "dana@lindmetall.de",
  text: draft,
})

Spaces

## One space per customer

Everything above, handed through. Each customer gets a space: their domain or connected inbox, every thread that went through it, and every event stamped with it. Rules live in a space too, so a customer can set their own hours and caps from inside your product — and only their own mail waits for them.

Example: your workspace sets an account cap of 2,000 emails per hour. Inside it, customer Harbourly's space holds harbourly.com and tom@harbourly.com with a warm-up of 1 per 2 minutes per sender, and customer Rheinbau's space holds rheinbau.de and jana@rheinbau.de with office hours Mon–Fri 09:00–18:00 Berlin. Harbourly is sending while Rheinbau's mail waits for Monday morning; neither ever sees a thread of the other's, and the account cap counts both.

Developers

## Two calls and you’re live

One to send. One webhook to hear back.

TypeScript

```
const email = await aiinbx.emails.send({
  from: "nora@northwind.io",
  to: "dana@lindmetall.de",
  subject: "RFQ 4471 — 3mm brushed sheets",
  text: draft,
  suppression_key: "q4-outbound",
})

// Sunday, 02:47. A pacing rule holds it until Monday morning.
email.status                    // "queued"
email.pacing.estimated_send_at  // "2026-08-31T07:00:00Z"
email.pacing.held_by            // { kind: "hours", rule_id: "pace_…" }
```

Sent on a Sunday night. The response says which rule held it, and until when.

Platform

## Everything else, handled

The parts every email API needs, done properly so you never think about them.

-   Domains: Add a domain and we tell you exactly which DNS record is wrong.
-   Regions: EU or US, chosen per domain and per mailbox. Mail is processed and stored there.
-   Webhooks: Signed, retried, and replayable for when your server was down.
-   Sending: Attachments, cc, bcc, and retries that never double-send.
-   Scheduled send: Pass a timestamp and the email goes out exactly then. Move or cancel it until it does.
-   Search: Find a thread by what it was about, not the exact words.
-   Metrics: Spot bounces and complaints before a provider throttles you.
-   Tracking: Opens and link clicks, in the metrics and on your webhook.
-   Wildcard domains: Connect \*.domain.com once, then create as many subdomains as you want without a single new DNS record — one for every customer to send from.

## Give your product an inbox. The hard parts are already handled.

[Get started](/signup)