Form backends have a structure problem.
Postbox is structured data collection for the agentic web. Define your schema, get an endpoint where submissions arrive validated, spam-filtered, translated and auto-replied.
Three steps. All conversation.
Connect.
Install the Postbox Skill, or connect the MCP server. One-time setup. Your agent now knows how to create and manage forms on its own.
Describe.
"Add a waitlist form." That's the whole brief. Your agent defines the schema, generates the UI, and wires up the endpoint — all in one go.
Listen.
Submissions land in one inbox. The contract holds for any source — form, tool, or agent.
Only you didn't have to.
Bad data never lands.
You define the schema. Postbox enforces it at the endpoint — types, required fields, patterns, ranges. Per-field errors come back structured.
Spam never makes it to your inbox.
Free heuristics out of the box. Flip on AI for spam that understands your form's intent — the junk that passes keyword filters but obviously doesn't belong.
Every language, one inbox.
Auto-detected and translated on the way in. The original is always kept — nothing lost in translation, nothing waiting for you to decode.
Questions answer themselves.
Point at a knowledge base. Postbox drafts a reply for every submission — or sends it on your behalf. The stuff you'd answer the same way every time, you stop answering.
Your agent already knows how to wire this up.
Inside your codebase.
Drop the Postbox Skill into your project once. From then on, your coding agent knows how to create forms, wire the endpoint, and drop the snippet into your UI — while it's shipping the rest of the feature.
Inside your chat.
Point any MCP-aware client — Claude, Cursor, your personal agent — at the Postbox server. Create forms, inspect submissions, change destinations. Without leaving the conversation.
{ "mcpServers": { "postbox": { "type": "http", "url": "https://usepostbox.com/mcp" } } }
Or just click through the dashboard.
The dashboard does everything the agent does. Fine for handing off to a client, or when you just want to poke around.
Every submission flows through this pipeline.
Validate, spam check, translate, reply, notify — configurable per form. Submitters always get 201 instantly; everything else happens async.
One of these, most likely.
Make a lasting first impression.
The forms that turn strangers into a list, and a list into a conversation. Waitlists that build anticipation, lead capture that routes straight to your CRM, demo requests that schedule themselves. Built for speed, volume, and the exact moment someone decides they are interested. Validation keeps garbage out. Spam filtering keeps noise down. Your pipeline stays clean from the first touch.
Most questions answer themselves.
Plug in your knowledge base and suddenly every submission gets a thoughtful, contextual response. Postbox drafts replies from your docs — or sends them on your behalf if you trust the match. Contact forms, bug reports, feature requests, refund inquiries. The questions you would answer the same way every time, you no longer answer at all. Your support team handles the edge cases while Postbox handles the routine.
The forms that run the process.
When the form isn't the goal — it's a step in something bigger. Vendor onboarding that triggers compliance checks. Internal requests that route to the right team. RSVPs that update headcount automatically. Structured input that drives a workflow instead of creating another spreadsheet to maintain. Every field maps to an action downstream, so data flows instead of piling up.
Surveys without the spreadsheet.
Surveys and polls that turn into structured data the moment they're submitted. User research that segments itself. Beta feedback that surfaces themes without manual tagging. Pricing studies that compare responses across cohorts. No spreadsheet wrangling, no copy-paste, no pivot tables — the answers arrive ready to read, filter, and act on. Your agent can even summarize patterns and draft follow-up questions from the same dataset.
The lads at the lab are always up to something.
Experiments from the edge of what data collection can be when agents are part of the loop.
The RSVP that ran itself.
We wired one agent to plan a dinner for thirty. It created the form on Postbox and sent the endpoint to everyone else's agents. RSVPs flowed in structured — dietary prefs, plus-ones, confirmations. Nobody opened a browser.
One prompt. Fully wired.
"I need a contact form on the website." That's the whole brief. The agent creates the schema on Postbox, builds the UI, connects the endpoint, and deploys — all in one shot.
The free plan isn't a trial.
- Unlimited forms
- Unlimited submissions
- Webhooks, Discord, and Slack destinations
- 500 AI credits per month, replenishing
- Pay as you go after credits run out
- Priority support
The questions we keep getting.
What happens when I hit the 5,000 submission cap? +
Do you support file uploads? +
How do I get submissions into my own systems? +
Can I export my submissions if I leave? +
Does Postbox work with my framework? +
What if I need to change a form's schema later? +
Can my non-technical client manage forms themselves? +
How is this different from Typeform or Google Forms? +
What does "agent-native" actually mean? +
Is there a limit on how many submissions I can receive? +
How does the spam filtering work? +
This form runs on Postbox.
Built with the same Skill you'll install. Every message hits our live endpoint — validated, spam-checked, and in our inbox before you close the tab.