MailFrame — frequently asked questions

MailFrame is a developer-first API that turns raw email into typed, schema-validated JSON. You POST the raw RFC 822 MIME of an email to /v1/parse, alongside a JSON Schema describing the fields you want, and MailFrame returns the validated JSON in the HTTP response. No regex, no scraping, no per-sender rules to maintain.

Mailparser and Parseur are rule-based: you (or your ops team) configure per-sender rules that pick values out of predictable HTML layouts. MailFrame is schema-first: you define the JSON shape you want once, and a model extracts against that schema — so layout drift between senders (and across carriers, vendors, and notification types) is handled by the same code path. Mailparser and Parseur also ship no-code template editors and a deep catalog of native integrations; MailFrame is API-first and feeds whatever downstream system accepts a webhook.

Zapier's Email Parser is a no-code mailbox-and-highlight tool that creates triggers for Zaps. MailFrame is a POST endpoint that returns typed JSON synchronously and — for teams that prefer asynchronous delivery — signs and queues HMAC-SHA256 webhook deliveries with retries, attempt history, dead-letter, and replay (webhook delivery is available in early access). If you're already inside the Zapier ecosystem and your flow is short, Zapier is fine; if you need typed data going into your own service with a clear delivery contract, MailFrame is built for that.

App developers integrating inbound document email (receipts, invoices, shipping notifications, GitHub alerts, payment confirmations) into their own service. MailFrame is not built for no-code spreadsheet users, not for enterprise AP automation, and not for RAG pipelines — for those workflows, an existing rule-based or no-code tool will fit better.

No. MailFrame does not send email and does not host inboxes for forwarding. You fetch or receive the raw email yourself (from your own IMAP poll, from your transactional provider's inbound webhook, from a SES rule, etc.) and POST it to /v1/parse. Inbox forwarding to a MailFrame-provided address is on the roadmap.

You send a POST request with three things: a bearer token (Authorization: Bearer ${MAILFRAME_API_KEY}), the raw email content as raw_mime (or a plain-text email-like string), and a schema_id pointing at a pre-built schema by name or an inline JSON Schema describing the fields you want. MailFrame extracts against the schema, validates the result, and returns the typed JSON in the response. The docs page shows full curl, TypeScript, and Python examples end-to-end.

No. Every schema in the library is a starting point. You can supply your own inline JSON Schema on any /v1/parse request when the sender you need isn't in the library yet — extraction is validated against whatever schema you send. Pre-built schemas cover Stripe receipts, Shopify orders, PayPal receipts, Amazon orders, Apple App Store and Google Play receipts, GitHub notifications, invoice and payment-due emails, travel booking confirmations, and shipping / delivery notifications.

Raw RFC 822 MIME — the wire format of every email — or plain-text email-like input. Multipart messages, nested MIME parts, and common transfer encodings (base64, quoted-printable) are handled. PDF and image input are planned but not yet shipped.

Synchronously, in the HTTP response to your POST /v1/parse request — the body contains the typed data payload, the parse status, and any schema validation errors. Signed HMAC-SHA256 webhook delivery — with retries, attempt history, dead-letter, and replay — is available in early access for teams that prefer asynchronous delivery.

A typical successful response is {"id": "parse_<short>", "status": "completed", "validation_errors": [], "data": { ...your typed fields... }}. On failure, you get a clear error envelope ({"error": {"type": "...", "message": "...", "request_id": "..."}}) with appropriate HTTP status codes. Failed validation does not error the request — the typed data and the validation errors are both returned so you can decide what to do.

There are five tiers: Free (100 parse operations per month, no credit card), Indie $19/mo (500 ops), Startup $49/mo (5,000 ops), Scale $149/mo (50,000 ops), and Enterprise (custom for 100k+ ops per month). You can see the full breakdown on the pricing page.

One schema extraction against one input. Running one email against two different schemas counts as two operations; running the same input against the same schema twice counts as two operations. Each /v1/parse call is one operation regardless of how many fields the schema defines.

Yes. The Free tier gives you 100 parse operations per month with no credit card, so you can validate MailFrame against your own emails before upgrading. There is also a free in-browser Stripe receipt parser that runs end-to-end with no signup at all.

You receive a 429 response with a clear error message. There are no retroactive overage charges — upgrade your tier to increase your limit, or wait for the next billing cycle. Quotas reset on the same calendar day each month you signed up.

No. Developers who join during early access keep the plan and pricing they sign up with. We give clear, advance notice before any future pricing change.

Yes — the Enterprise tier offers custom pricing for 100k+ operations per month, and we work with non-profits, educational users, and open-source maintainers on case-by-case pricing. Contact us through the access form on the homepage for details.

An email parser schema is a JSON Schema document that describes the exact fields you want extracted from an email — their names, types, and constraints (required/optional, patterns, enums). You hand it to MailFrame, MailFrame extracts against it and validates the result, and you get back typed JSON that matches the shape you defined.

Stripe receipts, Shopify orders, PayPal receipts, Amazon orders, Apple App Store receipts, Google Play receipts, GitHub notifications, invoice and payment-due emails, travel booking confirmations, and shipping / delivery notifications (FedEx, UPS, USPS, DHL). Browse the full library with example output and the exact JSON Schema for each sender.

If a schema declares a field as required and the email doesn't contain a value for it, MailFrame returns a non-empty validation_errors array alongside whatever data was successfully extracted. Optional fields that aren't present are simply omitted from the data payload. You decide in your client code how to react to either case.

Yes — send an inline JSON Schema on any /v1/parse request. There is no registration step. If you want to share a schema across multiple environments, version it in your own code and reference it by name (the JSON Schema title) on each request.

The model is given the schema, not the sender's HTML layout. When two senders of the same type (two different Stripe accounts, two different Shopify stores) produce slightly different email formats, both produce JSON that validates against the same schema — the extraction adapts per-email rather than per-rule.

Yes. You POST the email and the response carries the parsed JSON in the same HTTP round-trip. The configured request timeout is 30 seconds — clients should set their own HTTP client timeout accordingly.

When you opt into async delivery (available in early access), MailFrame sends each delivery as an HTTP POST with an `X-MailFrame-Signature` HMAC-SHA256 signature and an `X-MailFrame-Timestamp` header; your endpoint verifies the signature against the shared secret you configured at signup, and MailFrame retries with exponential backoff on non-2xx responses. Every attempt is recorded with HTTP status, response body excerpt, and timing; failed deliveries land in a dead-letter queue you can replay from. The webhook endpoint must respond 2xx within 10 seconds.

Webhook delivery is in early access; documented behavior is the same as for the synchronous endpoint with retries layered on top. The retry schedule uses exponential backoff with a 24-hour maximum window, after which a delivery moves to the dead-letter queue. There is no hard cap on attempts within that window. Replay from the dead-letter queue is unlimited. Specific retry counts and timing are subject to refinement during early access — pin the published version of the docs that ships with your access.

The status page shows posted operational status for the API, parse engine, dashboard, docs, and webhook delivery subsystems, including historical uptime and any ongoing incidents.

Inbound email content is processed by the MailFrame parse pipeline and the resulting JSON is returned to you. We retain raw email content for the minimum time needed to deliver your response and surface debugging, and we don't sell or share customer data. API keys are stored hashed; webhook signing secrets are shown once at creation and stored encrypted. See the security and trust page (/security/) for our data-handling, authentication, and compliance posture; full security details are available on request before you sign an Enterprise agreement.

SOC 2 Type II certification is part of the post-Enterprise-launch roadmap. MailFrame is in early access today, and the team is documenting the controls and audit posture now. Enterprise customers can request the current security questionnaire response and a working-data-processing addendum as part of their agreement.

MailFrame is not yet HIPAA-eligible as a Business Associate, and you should not send PHI through the API without a signed BAA. For PCI: the schemas for Stripe and payment processors return last-four digits and card brand, never full PAN, so parsed output itself is out of PCI scope; you remain responsible for how your downstream systems store the parsed data.

PDF and image input (parse the body of an attached PDF or a screenshot of a receipt), inbox forwarding to a MailFrame-provided address per customer, Stripe self-serve billing, SOC 2 Type II, and an async / batch parse mode for high-volume ingestion. Today, the current shipped integration path is the synchronous POST /v1/parse with the parsed result returned in the same HTTP response; signed HMAC webhook delivery with retries, attempt history, dead-letter, and replay is available in early access.

MailFrame is in limited early access — we're onboarding developers in weekly batches. Request access through the form on the homepage and you'll get API keys when your spot opens. You can also try the free in-browser Stripe receipt parser today, no signup required.