Skip to content
nofeb

Email for AI agents, built for the developers who ship them

For developers building autonomous and semi-autonomous agents

nofeb is an email API built for agents rather than for people or for bulk sending. An agent can create its own organization, inbox and key in one call, receive mail immediately, wait for a code without polling, read every message as model-safe text with typed decisions already attached, search everything it can see, and reply in the same thread, with a sending policy the server enforces.

Checked against the engine on .

What gets in the way?

  • Agents hit email walls everywhere: sign-ups, verification codes, magic links, vendors who only answer by email.
  • Lending an agent a human Gmail or Outlook account means a person creating it, consumer terms, and an account that can be suspended for automated use.
  • Sending APIs send; they do not give the agent an inbox to live in, a thread to reply into, or a way to wait for the next message.
  • Whatever lands in the inbox goes into a model's context, so every stranger who can email the agent can try to instruct it.

How does nofeb handle it?

Inboxes on demand

Create as many inboxes as the work needs, each with a generated or chosen address, optional time to live and its own autonomy tier. Paid plans do not charge by the inbox.

An agent can start alone

POST /v1/agent/signup returns a key and a working inbox. Until a human sponsor verifies, the agent may only reply to people who wrote to it first, so a fresh signup cannot be used for cold mail.

Mail an agent can read

Every message carries reply_text, safe_body, extracted one-time codes and classified links, attachment text, a prompt-injection score with its reasons, and typed decisions such as intent, needs-reply and automated, each with a probability. wait_for_email blocks until a matching message arrives.

Memory it can search

search_email finds messages by meaning as well as by words across every inbox the key can see, and query_threads finds threads by their metadata, such as every thread at a given stage whose last message went unanswered for a day.

State on the thread

Typed metadata on messages, threads and inboxes, and follow_up_at timers that emit thread.due, so an agent keeps its working memory where the mail is.

One policy for every surface

REST, the TypeScript and Python SDKs, the remote MCP server (with API keys or OAuth sign-in), JMAP, IMAP and SMTP submission all work on the same mailboxes, and the inbox's autonomy tier is enforced on the server for every one of them.

The nofeb inbound pipeline Two entry points, nofeb's own MX and provider webhooks authenticated by an inbound token, feed the same pipeline: sender authentication and spam and virus checks at the MX, routing by envelope recipient, the inbound.resolve hook, an injection score, sender trust and typed decisions, then sender lists, the inbound.pre_deliver hook and rules, delivery to the inbox, Junk or quarantine, then a message.received event by webhook or event feed, and access over REST or MCP for the agent. Ways in nofeb MX Any mail server delivers STARTTLS offered Recipient checked at RCPT Provider webhooks Cloudflare Email RoutingPostmark inbound streamMailgun routeSendGrid Inbound ParseAny raw POST /v1/inbound/…/{token} At the door Checks before 250 OK SPF · DKIM · ARC · DMARC Spam and virus scan Refuse, accept, or Junk Pipeline One pipeline Route by envelope recipient Delivered once, even if resent inbound.resolve hook Scored and triaged injection score, sender trust decisions on every message sender lists inbound.pre_deliver hook rules quarantine, reject or file Parsed for the model reply_text · safe_body codes, links, attachments extracted metadata security verdict Inbox Agent inbox Inbox, Junk or quarantine Typed metadata on the thread Raw message kept byte-exact The agent hears message.received webhook, event feed or stream wait_for_email long-poll until it arrives Agent: REST, SDK or MCP
Mail from any sending server reaches nofeb's MX; mail already handled by Cloudflare Email Routing, Postmark, Mailgun or SendGrid is passed on with your inbound token. Both join the same pipeline, where each message is scored for injection, labelled and triaged before your sender lists, hooks and rules decide its fate, and the agent hears about it by webhook, the event feed, the stream, REST or MCP.

What does the code look like?

An agent signs itself up (REST)
curl -X POST https://api.nofeb.com/v1/agent/signup \
  -H 'content-type: application/json' \
  -d '{"name": "research agent", "sponsor_email": "owner@example.com"}'
# → { "api_key": "nfb_…", "inbox": { "address": "…@agents.nofeb.com", … }, … }
Get an inbox and wait for a code (TypeScript)
import { Nofeb } from "@nofeb/sdk";

const nf = new Nofeb(); // reads NOFEB_API_KEY

const inbox = await nf.inboxes.create({ local_part: "signup-bot", ttl_seconds: 3600 });
const since = new Date(); // before the form is submitted

// … type inbox.address into the sign-up form …

const { message } = await nf.inboxes.waitForEmail(inbox.id, { has_otp: true, timeout: 60, since });
const code = message?.otps[0]?.code; // "482913"
Reply in-thread and record state (TypeScript)
const thread = await nf.threads.get(message.thread_id); // oldest first, safe_body text, metadata

await nf.messages.reply(message.id, { text: replyText });// threading headers set for you
await nf.threads.setMetadata(message.thread_id, {
  stage: "quote_sent",
  follow_up_at: "2026-10-07T09:00:00Z",                 // thread.due fires then
});
The same as MCP tool calls
create_inbox    { "local_part": "signup-bot", "ttl_seconds": 3600 }
wait_for_email  { "inbox_id": "inb_…", "has_otp": true, "timeout": 60 }
→ { "message": { "otps": [{ "code": "482913", "source": "body" }], "links": [ … ], … } }

Where does nofeb stop?

  • nofeb is not a bulk or marketing sender, and it does not act inside people's existing Gmail or Outlook mailboxes.
  • It gives the agent mail, state and limits; the reasoning and the prompts stay in your code.

Frequently asked questions

What is the best email API for AI agents?

One that gives the agent an inbox, not just a send endpoint: addresses created by API, threads it can reply into, a way to wait for mail, text that is safe to hand a model, and limits on what it may send. nofeb is built around exactly those, with REST, SDKs and MCP.

Can an AI agent have its own email address?

Yes. With nofeb the agent can create one itself with POST /v1/agent/signup, or you create inboxes for it. Each is a real address any sender can reach.

What is the difference between an email API and an inbox API?

An email API sends messages from an application. An inbox API gives software a mailbox: it receives, threads, stores, and lets the software read and reply. Agents need the second.

Can my agent search its own mail?

Yes. POST /v1/search (the search_email tool) combines full-text and semantic search over every inbox the key can see, with filters for sender, date, folder, attachments and metadata, and can group results by thread.

How is nofeb priced?

By usage, not by inbox, on paid plans: a monthly allowance of messages processed and storage, metered past it. The pricing page has the table.

Status of everything on this page

Every capability named above, with its status as reconciled against the engine.

CapabilityWhat it doesStatus
Unlimited inboxes Create as many inboxes as the work needs, with a generated or chosen address and an idempotent client reference. Shipped
Agent self-signup with a human sponsor An agent creates its organization, first inbox and API key in one unauthenticated call. Until the human sponsor it names verifies by email, it may only reply to people who wrote to it first. Shipped
Sponsor gating on unverified organizations Until a human sponsor verifies, an organization may only reply, and only to addresses that wrote to it in that thread. Shipped
Wait for an email Long-poll an inbox for up to a minute until a message matching sender, subject or has-a-code arrives. Shipped
One-time code and link extraction Verification codes and classified links are pulled out of every message and returned as fields. Shipped
safe_body for untrusted mail The message's new text with zero-width and direction-altering characters, hidden HTML and forgeable quoted history removed, wrapped in a provenance header that tells the model whose words these are. Shipped
Injection scoring and quarantine Every inbound message gets a prompt-injection score from 0 to 1 with its reasons: hidden text, invisible and look-alike characters, instructions aimed at an AI, role and chat-template tokens, tracking beacons, data-carrying links and encoded payloads. Above the threshold you set per organization, pod or inbox, the message is quarantined (or only flagged) for a person to release or delete, and its content stays out of the delivery event. Shipped
Decisions on every message A default set of typed decisions on every inbound email (intent, urgency, needs-reply, automated, verification email, phishing, injection risk, requires-human and language) with a probability each, your own decision schemas beside them, human relabels that correct and retrain it, per-question accuracy and calibration stats, and confidence-gated sending for the send_when_confident tier. Decisions run without leaving nofeb by default; a third-party model sees mail only if you opt in. Shipped
Search that understands Full-text and semantic search over subjects, addresses, the new text of each message, attachment names and attachment text, across every inbox a key can see. Filter by inbox, pod, folder, thread, sender, recipient, date, attachments, keywords, authentication failures and metadata; results carry highlighted snippets and can be grouped by thread. Shipped
Queries across threads by metadata Find threads across inboxes and pods by typed metadata values and ranges, by decision probabilities, and by the direction and age of their last message (every thread at stage quote with no reply for four hours), plus an inbox directory searchable by metadata. Shipped
Typed metadata on messages, threads and inboxes Merge-patch keys onto a message, a thread or an inbox, and declare a key's type so every write to it is validated. Shipped
Follow-up timers Set follow_up_at on a thread and, when that time passes, a thread.due event carrying the thread's metadata goes to your webhooks and the event feed, so agents need no scheduler of their own. Shipped
MCP server A remote MCP server over streamable HTTP whose tools are generated from the same operation table as the REST API and dispatched through the same router, so a tool cannot behave differently from its endpoint. Shipped
MCP sign-in with OAuth MCP clients connect by signing in instead of pasting a key: OAuth 2.1 with discovery, dynamic client registration, client ID metadata documents, PKCE, tokens bound to the MCP server, refresh-token rotation and immediate revocation. A person approves the scopes, and optionally one inbox, in the console, and can disconnect the app at any time. API keys keep working beside it. Shipped
TypeScript and Python SDKs Official clients generated from the OpenAPI document: @nofeb/sdk for Node, Deno, Bun and edge runtimes, and nofeb for Python with sync and asyncio clients. Both chain long polls for waitForEmail, retry idempotent requests, page through lists and verify webhook signatures. Shipped
JMAP JMAP Mail, submission, vacation responses and push, one account per inbox a key can see, sharing one change history with the API and IMAP, with extensions for typed metadata and approvals. A send over JMAP meets the same autonomy tiers as any other. Shipped
IMAP and POP3 IMAP4rev2 (with IMAP4rev1 compatibility, IDLE, CONDSTORE and QRESYNC) and POP3 on every inbox, over TLS only, signed in with the inbox address and an API key or a revocable per-inbox app password. Shipped
SMTP submission Authenticated SMTP submission on ports 587 and 465 for tools that only speak SMTP. Every submitted message meets the same autonomy tiers, approvals, lists, caps and hooks as an API send, and a held message is accepted and reported as held. Shipped
Autonomy tiers enforced by the server Every inbox carries a sending policy, from read-only to autonomous, enforced on the server for every surface that sends, so switching from the API to MCP cannot bypass it. Shipped