# Frequently asked questions

Real, delivered email you can assert on — built for software teams and the AI agents that build with them. Below: how fixture.email works, how agents and keys fit in, and how billing is metered. Still stuck? Email [support@fixture.email](mailto:support@fixture.email).

## The basics

### What is fixture.email?

fixture.email is end-to-end email testing for software teams and the AI agents that build with them. You mint disposable mailboxes, send and receive **real** email, and assert on the exact subject, body, links, and headers your users actually get — in your end-to-end tests, in the CI you already run.

### Is this real email, or mocks?

Real email, actually delivered: fixture.email sends and receives genuine messages, never stubs or mocks. Your app sends to a fixture.email mailbox address, the message is received and parsed, and you assert against what arrived — subject, body, decoded links, and lowercased headers. Every send carries SPF, DKIM, and DMARC and a Message-ID whose host matches the sender, so what you test mirrors production.

### Will my tests be flaky?

fixture.email tests are deterministic by construction, not by retry: every mailbox is uniquely addressable and isolated, so the same test passes the same way on every run — no shared state, no cross-talk, no retry-until-green. Status and message reads are deterministic facts you can poll or drive from a signed callback, and simulated outcome sink addresses let you exercise bounces and complaints on demand.

### Does it work in my CI?

Yes — fixture.email runs in the CI you already have. It is plain HTTP your runner already speaks (mint a mailbox, send to it, then read the messages back), so it drops into GitHub Actions, GitLab CI, or whatever you run today with no special agent or runner.

## Built for agents

### How do agents fit in?

fixture.email is agent-native: it ships a Model Context Protocol (MCP) server, not just an SDK. Point your AI coding agent at the fixture.email MCP and it does the wiring — it reads the docs, mints mailboxes, and drafts the email assertions straight into your suite. There is no SDK to learn and no dashboard to click through: a developer pastes a starter prompt once and the agent drives the whole receive → send → assert loop over the MCP.

### MCP or HTTP API?

Both — fixture.email exposes a full MCP server and a plain HTTP API, on one `X-API-Key`. The two surfaces expose the same capabilities, so your agent can call the tools natively while your CI hits plain HTTP: no second credential, no divergent surface.

### What is your approach to AI in testing?

fixture.email treats a deterministic API as the anchor and AI as an advisory layer on top. The API gives reproducible ground truth (arrived, headers, links, auth results, signed callbacks), and the AI layer helps author assertions from intent and judge the fuzzy half of email no selector ever captured. The rule that keeps it trustworthy: an AI judgment never overrides a deterministic verdict, and zero deterministic checks is a failure, never a silent pass.

## Keys & access control

### How fine-grained is API-key access control?

fixture.email scopes access per KEY, not per account. Every key is org-scoped and hashed, and each key carries a precise **grant**: a tier (Org-Admin, Mailbox-Admin, or Mailbox) × a named set of mailboxes × the message classes it can touch (Inbox, Sent, or Tag) × the actions it can take (List, Read, Delete) — with the right to send folded into the same grant. A confined key only ever sees what its grant allows: a mailbox or message outside the grant returns `404` (it can't even learn the thing exists), and an in-grant action it lacks returns `403`.

### How are confined keys created and delivered?

fixture.email keys are created programmatically — not dashboard-only. You author keys over the HTTP API or via the `provision_keys` MCP tool (an agent can mint a scoped key from a natural-language request), and the raw secret is revealed **once** in the fixture.email portal through an inert, org-bound claim link. The secret never lands in an agent transcript, a tool result, or our logs — the human reveals it in the portal and copies it into their secret store.

### Can I give mailboxes stable names?

Yes — fixture.email mailboxes carry unique-per-org **labels** as stable, human-friendly handles, so a grant can name a set of mailboxes that stays meaningful as the underlying addresses rotate.

## Plans & billing

### What does it cost, and what is metered?

fixture.email is one plan, with everything needed to test email included. Only delivery to **real recipients outside your test domain** is metered — internal test-domain sends, message reads, and mailbox / key / callback management never draw on your send allowance. Scale the external-send allowance with 1–99 units at checkout, adjustable anytime in the billing portal. See the [pricing section](https://preview.fixture.email/#pricing) for the current figures.

### Is there a free trial?

Yes — fixture.email includes a 15-day free trial. A payment card is required up front, but you are not charged during the trial and can cancel anytime before it ends. The trial includes a starter external-send allowance so you can prove the full mint → send → assert loop end to end. See the [Refund Policy](https://preview.fixture.email/refunds) for the cancel-anytime details.

### Will my test mail land in the Gmail inbox?

fixture.email guarantees authenticated delivery and observability, not inbox placement. Every message it sends is properly authenticated (SPF / DKIM / DMARC, multipart/alternative, matching Message-ID host), but whether a third-party provider such as Gmail files a given message under Inbox or Spam depends on sender reputation and is best-effort — out of scope for a testing service.

## Choosing fixture.email

### How is this different from other email-testing tools?

fixture.email is built as the **combination** of two things the category usually separates: the deterministic ground truth of an email-testing harness, and an AI layer pinned on top of it. Deterministic harnesses (Mailosaur among them) are a solid way to capture and assert on mail; fixture.email adds an agent-native MCP that wires the integration for you, and the strongest programmatic per-key RBAC in the category — mint precisely-scoped keys over the API, not from a dashboard. We compete by extending what a deterministic tool does, not by taking anything away.

### How do I get started?

Getting started with fixture.email takes one checkout and one paste: start the 15-day trial, then paste the starter prompt into your coding agent — it connects to the fixture.email MCP, mints a mailbox, and proves a first send → assert. The [docs](https://preview.fixture.email/docs) walk through the HTTP API and the MCP if you'd rather wire it by hand.

More questions? Email [support@fixture.email](mailto:support@fixture.email), or read the [docs](https://preview.fixture.email/docs).