Hand it to your AI coding agent

Your coding agent can wire up Email Fast end to end — read the docs, install the SDK, write the code, and prove it works in the sandbox — while nothing real is ever sent.

The whole idea

You already have an assistant that writes code. Let it do the integration. Point your coding agent at our docs, give it a key that can't send anything real, and tell it what email you want. It reads, writes, and tests — you review the result.

Because our documentation is built for machines as much as people — a markdown mirror on every page, an llms.txt, and a real OpenAPI spec — an agent doesn't have to guess at our API. It reads the source of truth.

Three steps

1. Give it a sandbox key. Grab one from get started. Sandbox keys start with ef_sandbox_ and run the whole pipeline dry — nothing sends.
2. Point it at our docs. emailfast.dev/llms.txt plus the quickstart for your stack.
3. Tell it what to send. "Send a welcome email on signup." That's the whole brief.

Watch it happen

Here's the same session, start to finish — the developer asks, the agent reads our docs, installs the SDK, writes the handler, and runs a sandbox test that comes back green. This is illustrative, but every step is a real thing the tools do today.

// app/api/signup/route.ts  — written by the agent
import { EmailFast } from "@email-fast/nodejs";

const ef = new EmailFast({ apiKey: process.env.EMAILFAST_API_KEY });

export async function POST(req) {
  const { email, name } = await req.json();
  await ef.send({
    to: email,
    subject: `Welcome, ${name}!`,
    html: `<h1>Hi ${name} 👋</h1><p>Glad you made it.</p>`,
    idempotency_key: `welcome:${email}`, // a retry can't double-send
  });
  return Response.json({ ok: true });
}

The message never left the building. In the sandbox it's validated, queued, and captured — so the agent can show you exactly what would have gone out:

The prompt to paste

Copy this into your agent, fill in the blank, and let it work:

Integrate Email Fast (emailfast.dev) into this project.
- Read https://emailfast.dev/llms.txt and the quickstart for our stack.
- Install the official SDK and use a sandbox key (ef_sandbox_...), read from the environment.
- Add: ⟨what you want — e.g. "a welcome email when a user signs up"⟩.
- Then run it against the sandbox and show me the captured message.
Do not use a live key; nothing real should send.

Works with the agent you already use

Claude Code, Cursor, GitHub Copilot, Windsurf, Cline, Aider — anything that can read a URL and run your terminal. No special integration is needed today; the docs are the interface. A dedicated MCP server is on the what's-arriving list.

Then go live, when you're ready

Nothing above touched production. When the captured message looks right, swap the sandbox key for a live one and the exact same code sends for real — on infrastructure we run ourselves, with a delivery receipt you can verify. Get a key →