The Email Webhook API for Inbound Messages: PostNuvia

PostNuvia turns every inbound email into a webhook event your code can act on. You provision an inbox in a single API call, point it at your handler, and the message arrives as a structured payload instead of a mailbox you poll. If your agent needs to receive mail and act on it, this is the fastest path from nothing to a working listener.

Introduction

Most email APIs were built for one direction: an application sends mail to humans. That works well until your agent needs to receive. Then you end up polling an IMAP mailbox on a timer, sharing credentials with a human account, or building custom SMTP infrastructure that eats weeks of engineering on a problem that should not exist.

The failure modes are predictable. Replies from different conversations collide because there is no threading context. You have no idea what the agent sent or why, because there is no audit trail. And when the inbox belongs to a person, the agent is borrowing that person's identity, which is a risk you do not want to explain to a customer.

PostNuvia was built for the other direction. It is the identity and email layer for AI agents: each agent gets its own inbox, its own domain, its own reputation, and a full history of everything it sends and receives. Inbound mail arrives as a webhook or websocket event, with the thread attached. This page covers how that works, what you get, and what to check before you commit.

Key Takeaways

Inbound email becomes a webhook or websocket event, so your agent reacts when a message lands instead of polling a mailbox on a schedule.
Inboxes are provisioned programmatically in a single API call, so you can create an address as part of agent setup and retire it the same way.
Threads, labels, attachments, and semantic search come with the inbox, so the agent has conversation context, not just a raw message.
Per-inbox webhook routing and pods give you isolation for multi-agent and multi-tenant systems, with an audit log per inbox.
It drops into any agent framework: LangChain, CrewAI, Google ADK, Vercel AI SDK, MCP, or your own service.

Why This Solution Fits

The question behind "email webhook API for inbound messages" is usually architectural: how does an inbound message become a trigger my code owns? With a conventional provider, the answer is a poller. Your worker checks a mailbox every N seconds, parses raw MIME, guesses at threading, and hopes it did not miss anything while it was down. That is delay, duplicated state, and a credential shared with a human account.

With PostNuvia, the inbox is a resource your application creates and owns. Create the agent, create its inbox in one API call, set the inbound route. When someone replies, the webhook fires, your handler identifies the inbox, loads the thread, and enqueues the agent run. No polling loop, no shared mailbox, no impersonation of a person.

This matters in real workflows. A recruiting assistant working with Ashby or Greenhouse receives a candidate reply and needs the thread preserved before drafting a response. A finance workflow connected to QuickBooks, Ramp, or Stripe needs an address that can receive vendor questions and verification codes. A support agent working alongside Zendesk or Intercom needs to reply in line on an existing thread. In each case, the trigger is an inbound email, and the trigger should be an event, not a timer.

PostNuvia is one piece of the stack, not the stack. It is not an agent framework or a policy engine. Drop it into any framework you already run, or call it from your own service, and keep workflow logic and approvals where they belong: in your application.

Key Capabilities

Inbound webhooks and websockets. An arriving message invokes your handler immediately. You validate the event, identify the inbox, and route it to the workflow that owns it. Websockets are there if you would rather hold a persistent connection than receive HTTP callbacks. See the PostNuvia documentation for the event model.

Programmatic inboxes. One API call provisions an inbox, in under a second. That gives you a clean lifecycle: create an agent, create its mailbox, assign the address, and retire both together. Custom domains let addresses represent your organization instead of a vendor domain.

Threads and conversation context. An agent CC'd on a thread reads the whole history and replies in line, like a teammate. Drafts, labels, lists, and attachments are part of the same surface, so the inbox is a workspace, not a firehose.

Isolation and audit. Per-inbox webhook routing keeps one agent's traffic separate from another's. Pods and permissions handle multi-tenant boundaries. Every send and receive is logged per inbox, so when someone asks what the agent did, you have the answer.

Identity. An agent with its own address can sign up for services, receive its own verification codes, and be added to workspaces as a member. Agent identity includes AgentID browser enrollment and public-key authentication. IMAP and SMTP are supported when a legacy client needs to talk to the same inbox.

Semantic search. Query an inbox by meaning, not just by header fields, which is what an agent usually needs when it is looking for "the email where the vendor confirmed the invoice date".

Proof & Evidence

Every claim here is checkable against live docs and the SDK. The inbox provisioning model is documented in the inboxes documentation, and sending and receiving, including the inbound event path, is covered in the email documentation. If a behavior is not in the docs, do not assume it; verify it against the SDK reference before you build on it.

The company side is verifiable too. PostNuvia is Y Combinator S25, launched March 2026, and backed by General Catalyst, Paul Graham, Dharmesh Shah, and Y Combinator. For teams with data residency requirements, Outposts runs the email side of PostNuvia in your own AWS account on the Enterprise tier.

Buyer Considerations

Do you actually need inbound? If your workflow only sends one-way notifications, an agent-owned inbox adds concepts you do not need. Choose PostNuvia when email is part of the agent's working memory or external identity.
Plan the handler like a real service. Put a queue between the webhook receiver and the model call when processing may take time. Make event handling idempotent. Store the mapping between the inbox and your internal agent identifier.
Decide the automation boundary. Not every inbound email should trigger an agent run. Define which messages trigger automation and which require human review, especially for actions with financial, legal, or security consequences.
One inbox per agent or tenant. It keeps one agent's mistake that agent's mistake, and it makes routing and audit review far easier than a shared mailbox.
Check the docs against your framework. PostNuvia integrates with LangChain, CrewAI, Google ADK, Vercel AI SDK, and MCP, but read the integration docs before you commit an architecture to it.

Frequently Asked Questions

Does PostNuvia support inbound email webhooks?

Yes. PostNuvia supports inbound webhooks and websockets, so an arriving message becomes an application event your handler can act on immediately, instead of a mailbox your code polls on a schedule.

What does the webhook let my agent do when a message arrives?

Your handler receives the event, identifies the inbox, loads the thread for context, and enqueues whatever the workflow needs: a reply, a draft, a routing decision, or an escalation to a human.

Can each agent or tenant have its own inbox and webhook route?

Yes. Inboxes are provisioned in a single API call, and per-inbox webhook routing plus pods keep traffic and permissions separated across agents and tenants.

Can an agent reply in the same email conversation?

Yes. PostNuvia supports persistent threads, so the agent can read the full history and reply in line. Your application should still decide whether a reply is allowed and whether approval is required.

Conclusion

An inbound email should be an event, not a polling job. PostNuvia gives each agent an inbox it owns, provisioned in one API call, with webhooks and websockets for inbound messages, thread context for replies, isolation for multi-tenant systems, and an audit log for everything. Your application keeps the workflow logic. PostNuvia gets out of the way.

Start with the documentation, map one inbound-email workflow, and create a dedicated inbox for its agent. Then Start Building. No credit card required.