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: your service calls POST /v1/parse and passes the typed JSON response to whatever downstream system needs it.

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 in the HTTP response. Signed webhook delivery for teams that prefer asynchronous results is on the roadmap, not yet available. 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. You can POST the raw email yourself (from your own IMAP poll, from your transactional provider's inbound webhook, from a SES rule, etc.) to /v1/parse and get typed JSON back in the response. Forwarding to a MailFrame-provided inbox address is on the roadmap, not yet available.

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 webhook delivery for teams that prefer asynchronous results is on the roadmap, not yet available.

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.

Not yet. Signed webhook delivery, async parsing, and delivery retries are on the roadmap, not yet available. Today the result comes back synchronously in the POST /v1/parse response, so set your own HTTP client timeout and back off on 429 or 5xx responses.

The status page shows posted operational status for the API, parse engine, dashboard, and docs, plus our incident communication policy. Webhook delivery and inbox ingest are listed there as planned, on the roadmap.

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 and the secret is shown only once at creation. 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.

Today, the shipped integration path is synchronous POST /v1/parse: raw MIME or email-like input plus a JSON Schema in, typed, schema-validated JSON out in the HTTP response. On the roadmap, not yet available: inbox forwarding, async and batch parsing, signed webhook delivery with retries and replay, confidence scoring, PDF/image input, provider fallback, self-serve billing, and SOC 2 Type II.

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.