How is programmable email different from an email API?

An email API sends mail from code. Programmable email adds the return path — inbound email delivered as JSON to a webhook — and an inbox identity per app or agent, so your software can both send and receive on the same verified domain.

Can an AI agent have its own email inbox?

Yes. With programmable email you give an agent a real address on a domain you control. Inbound mail arrives as parsed JSON; the agent replies over the Send API. You can run the model loop yourself or let MailKite run it on a durable queue.

MailKite

Email for devs and the agents they build

Programmable email for devs and agents.

Q: What is programmable email?

Programmable email is email you drive entirely from code: send with one API call, receive every message as structured JSON on a webhook, and give any app or AI agent its own inbox on a domain you control, with no mail server to run. Unlike a plain email API, which only sends, programmable email also receives, parses, and replies.

Receive any message as structured JSON, send with a single API call, and skip the mail server entirely. Give an agent its own inbox, or wire a whole domain — across unlimited domains and mailboxes, free. Set it up once and reuse it on every product you launch.

Start sending and receiving email

Start with Code Start with AI

Unlimited domains ·Unlimited inboxes ·3,000 emails/mo — no daily cap

incoming message msg_8f3a…

{ "from": "ada@example.com",
  "subject": "Re: invoice #1042",
  "attachments": [ "po.pdf" ] }

For developers

To hello@myapp.ai From ada@example.com Webhook POST /your/webhook 200

Outbound

POST /v1/send

delivered DKIM ✓

standing prompt inbox agent

prompt: "Reply to support requests yourself.
  Forward anything important to me at
  humans@myapp.ai."

For agents

To agent@myapp.ai From ada@example.com Agent MCP get_message ✓

Outbound

MCP send

delivered DKIM ✓

The category

What is programmable email?

Programmable email is email you drive entirely from code — send with one API call, receive every message as structured JSON on a webhook, and give any app or AI agent its own inbox on a domain you control, with no mail server to run. It turns email into a two-way programmable primitive: not just a way to send notifications, but a channel your software can also receive, parse, and reply on.

(Not to be confused with the marketing sense of the term — templated personalization in campaign emails. This is the developer definition: email as programmable I/O. Read the full breakdown →)

Send

One endpoint, one API key. Transactional mail, replies, and broadcasts over your own authenticated, warmed-up domain — built on Cloudflare's edge.

Receive

Point your MX at MailKite and every inbound message is parsed and POSTed to your endpoint as clean JSON — body, headers, and attachments. No IMAP, no mail server.

Agents

Give an AI agent its own address on a domain you own. It receives parsed mail, holds threads, and replies — bring your own model loop, or let MailKite run it.

SDKs

Use it from your stack

Official libraries for Node, Python, PHP, Java, Go, and Ruby — one shape everywhere — plus the CLI, plain REST, SMTP, and IMAP. Or flip to the agent path and connect any MCP client in one snippet.

send.ts

import { MailKite } from "mailkite";

const mk = new MailKite(process.env.MAILKITE_API_KEY);

const { id, status } = await mk.send({
  from: "hello@myapp.ai",
  to: "ada@example.com",
  subject: "Your invoice #1042",
  html: "<p>Thanks! Receipt attached.</p>",
});

Install GitHub Docs

app/api/send/route.ts

import { MailKite } from "mailkite";

const mk = new MailKite(process.env.MAILKITE_API_KEY);

export async function POST() {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return Response.json({ id, status });
}

Install GitHub Docs

app/routes/send.tsx

import { MailKite } from "mailkite";

const mk = new MailKite(process.env.MAILKITE_API_KEY);

export async function action() {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return Response.json({ id, status });
}

Install GitHub Docs

server/api/send.post.ts

import { MailKite } from "mailkite";

const mk = new MailKite(process.env.MAILKITE_API_KEY);

export default defineEventHandler(async () => {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return { id, status };
});

Install GitHub Docs

server.ts

import express from "express";
import { MailKite } from "mailkite";

const app = express();
const mk = new MailKite(process.env.MAILKITE_API_KEY);

app.post("/send", async (_req, res) => {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  res.json({ id, status });
});

Install GitHub Docs

src/index.ts

import { Hono } from "hono";
import { MailKite } from "mailkite";

const app = new Hono();

app.post("/send", async (c) => {
  const mk = new MailKite(c.env.MAILKITE_API_KEY);
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return c.json({ id, status });
});

export default app;

Install GitHub Docs

src/pages/api/send.ts

import type { APIRoute } from "astro";
import { MailKite } from "mailkite";

const mk = new MailKite(import.meta.env.MAILKITE_API_KEY);

export const POST: APIRoute = async () => {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return Response.json({ id, status });
};

Install GitHub Docs

server.ts

import { MailKite } from "mailkite";

const mk = new MailKite(Bun.env.MAILKITE_API_KEY);

Bun.serve({
  async fetch() {
    const { id, status } = await mk.send({
      from: "hello@myapp.ai",
      to: "ada@example.com",
      subject: "Your invoice #1042",
      html: "<p>Thanks! Receipt attached.</p>",
    });
    return Response.json({ id, status });
  },
});

Install GitHub Docs

src/worker.ts

// wrangler.jsonc → "compatibility_flags": ["nodejs_compat"]
import { MailKite } from "mailkite";

export default {
  async fetch(_req: Request, env: Env) {
    const mk = new MailKite(env.MAILKITE_API_KEY);
    const { id, status } = await mk.send({
      from: "hello@myapp.ai",
      to: "ada@example.com",
      subject: "Your invoice #1042",
      html: "<p>Thanks! Receipt attached.</p>",
    });
    return Response.json({ id, status });
  },
};

Install GitHub Docs

app/api/send/route.ts

import { MailKite } from "mailkite";

const mk = new MailKite(process.env.MAILKITE_API_KEY);

// Deploys as a Vercel Function — same code on Netlify or any Node runtime.
export async function POST() {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return Response.json({ id, status });
}

Install GitHub Docs

handler.ts

import { MailKite } from "mailkite";

const mk = new MailKite(process.env.MAILKITE_API_KEY);

export const handler = async () => {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return { statusCode: 200, body: JSON.stringify({ id, status }) };
};

Install GitHub Docs

supabase/functions/send/index.ts

import { MailKite } from "npm:mailkite";

const mk = new MailKite(Deno.env.get("MAILKITE_API_KEY"));

Deno.serve(async () => {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return Response.json({ id, status });
});

Install GitHub Docs

main.ts

import { MailKite } from "npm:mailkite";

const mk = new MailKite(Deno.env.get("MAILKITE_API_KEY"));

Deno.serve(async () => {
  const { id, status } = await mk.send({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  });
  return Response.json({ id, status });
});

Install GitHub Docs

send.py

import os
from mailkite import MailKite

mk = MailKite(os.environ["MAILKITE_API_KEY"])

res = mk.send({
    "from": "hello@myapp.ai",
    "to": "ada@example.com",
    "subject": "Your invoice #1042",
    "html": "<p>Thanks! Receipt attached.</p>",
})

Install GitHub Docs

views.py

import os
from django.http import JsonResponse
from mailkite import MailKite

mk = MailKite(os.environ["MAILKITE_API_KEY"])

def send(request):
    res = mk.send({
        "from": "hello@myapp.ai",
        "to": "ada@example.com",
        "subject": "Your invoice #1042",
        "html": "<p>Thanks! Receipt attached.</p>",
    })
    return JsonResponse(res)

Install GitHub Docs

app.py

import os
from flask import Flask, jsonify
from mailkite import MailKite

app = Flask(__name__)
mk = MailKite(os.environ["MAILKITE_API_KEY"])

@app.post("/send")
def send():
    res = mk.send({
        "from": "hello@myapp.ai",
        "to": "ada@example.com",
        "subject": "Your invoice #1042",
        "html": "<p>Thanks! Receipt attached.</p>",
    })
    return jsonify(res)

Install GitHub Docs

main.py

import os
from fastapi import FastAPI
from mailkite import MailKite

app = FastAPI()
mk = MailKite(os.environ["MAILKITE_API_KEY"])

@app.post("/send")
def send():
    return mk.send({
        "from": "hello@myapp.ai",
        "to": "ada@example.com",
        "subject": "Your invoice #1042",
        "html": "<p>Thanks! Receipt attached.</p>",
    })

Install GitHub Docs

send.php

<?php
$mk = new \MailKite\Client(getenv('MAILKITE_API_KEY'));

$res = $mk->send([
    'from' => 'hello@myapp.ai',
    'to' => 'ada@example.com',
    'subject' => 'Your invoice #1042',
    'html' => '<p>Thanks! Receipt attached.</p>',
]);

Install GitHub Docs

routes/web.php

<?php
use MailKite\Client;

Route::post('/send', function () {
    $mk = new Client(env('MAILKITE_API_KEY'));
    $res = $mk->send([
        'from' => 'hello@myapp.ai',
        'to' => 'ada@example.com',
        'subject' => 'Your invoice #1042',
        'html' => '<p>Thanks! Receipt attached.</p>',
    ]);
    return response()->json($res);
});

Install GitHub Docs

src/Controller/SendController.php

<?php
use MailKite\Client;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

class SendController
{
    #[Route('/send', methods: ['POST'])]
    public function send(): JsonResponse
    {
        $mk = new Client($_ENV['MAILKITE_API_KEY']);
        return new JsonResponse($mk->send([
            'from' => 'hello@myapp.ai',
            'to' => 'ada@example.com',
            'subject' => 'Your invoice #1042',
            'html' => '<p>Thanks! Receipt attached.</p>',
        ]));
    }
}

Install GitHub Docs

send.rb

require "mailkite"

mk = Mailkite::Client.new(ENV["MAILKITE_API_KEY"])

res = mk.send(
  "from" => "hello@myapp.ai",
  "to" => "ada@example.com",
  "subject" => "Your invoice #1042",
  "html" => "<p>Thanks! Receipt attached.</p>"
)

Install GitHub Docs

app/controllers/sends_controller.rb

class SendsController < ApplicationController
  def create
    mk = Mailkite::Client.new(ENV["MAILKITE_API_KEY"])
    res = mk.send(
      "from" => "hello@myapp.ai",
      "to" => "ada@example.com",
      "subject" => "Your invoice #1042",
      "html" => "<p>Thanks! Receipt attached.</p>"
    )
    render json: res
  end
end

Install GitHub Docs

app.rb

require "sinatra"
require "mailkite"

mk = Mailkite::Client.new(ENV["MAILKITE_API_KEY"])

post "/send" do
  res = mk.send(
    "from" => "hello@myapp.ai",
    "to" => "ada@example.com",
    "subject" => "Your invoice #1042",
    "html" => "<p>Thanks! Receipt attached.</p>"
  )
  content_type :json
  res.to_json
end

Install GitHub Docs

main.go

mk := mailkite.New(os.Getenv("MAILKITE_API_KEY"))

res, err := mk.Send(mailkite.Message{
	From:    "hello@myapp.ai",
	To:      "ada@example.com",
	Subject: "Your invoice #1042",
	HTML:    "<p>Thanks! Receipt attached.</p>",
})

Install GitHub Docs

Send.java

MailKite mk = new MailKite(System.getenv("MAILKITE_API_KEY"));

Object res = mk.send(Map.of(
    "from", "hello@myapp.ai",
    "to", "ada@example.com",
    "subject", "Your invoice #1042",
    "html", "<p>Thanks! Receipt attached.</p>"
));

Install GitHub Docs

SendController.java

@RestController
public class SendController {
    private final MailKite mk = new MailKite(System.getenv("MAILKITE_API_KEY"));

    @PostMapping("/send")
    public Object send() {
        return mk.send(Map.of(
            "from", "hello@myapp.ai",
            "to", "ada@example.com",
            "subject", "Your invoice #1042",
            "html", "<p>Thanks! Receipt attached.</p>"
        ));
    }
}

Install GitHub Docs

terminal

npm i -g @mailkite/cli && mailkite login

mailkite send --from hello@myapp.ai --to ada@example.com \
  --subject "Your invoice #1042" --html "<p>Thanks! Receipt attached.</p>"

mailkite messages tail   # watch inbound arrive

GitHub Docs

terminal

curl https://api.mailkite.dev/v1/send \
  -H "Authorization: Bearer $MAILKITE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "hello@myapp.ai",
    "to": "ada@example.com",
    "subject": "Your invoice #1042",
    "html": "<p>Thanks! Receipt attached.</p>"
  }'

GitHub Docs

terminal

wget -qO- https://api.mailkite.dev/v1/send \
  --header "Authorization: Bearer $MAILKITE_API_KEY" \
  --header "Content-Type: application/json" \
  --post-data '{
    "from": "hello@myapp.ai",
    "to": "ada@example.com",
    "subject": "Your invoice #1042",
    "html": "<p>Thanks! Receipt attached.</p>"
  }'

GitHub Docs

send.ts

// No SDK — one POST with the built-in fetch.
const res = await fetch("https://api.mailkite.dev/v1/send", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MAILKITE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    from: "hello@myapp.ai",
    to: "ada@example.com",
    subject: "Your invoice #1042",
    html: "<p>Thanks! Receipt attached.</p>",
  }),
});

const { id, status } = await res.json();

GitHub Docs

send.py

# No SDK — one POST with requests.
import os, requests

res = requests.post(
    "https://api.mailkite.dev/v1/send",
    headers={"Authorization": f"Bearer {os.environ['MAILKITE_API_KEY']}"},
    json={
        "from": "hello@myapp.ai",
        "to": "ada@example.com",
        "subject": "Your invoice #1042",
        "html": "<p>Thanks! Receipt attached.</p>",
    },
)

print(res.json())  # { "id": "msg_…", "status": "queued" }

GitHub Docs

.env

# Point WordPress, a CRM, or any app that speaks SMTP at the relay.
SMTP_HOST=smtp.mailkite.dev
SMTP_PORT=587            # STARTTLS · 465 for implicit TLS
SMTP_USER=mailkite       # any username works
SMTP_PASS=mk_live_…      # your MailKite API key — not a separate SMTP password
SMTP_FROM=you@your-verified-domain.dev

GitHub Docs

send.ts

import nodemailer from "nodemailer";

const tx = nodemailer.createTransport({
  host: "smtp.mailkite.dev",
  port: 587,                 // STARTTLS · use 465 for implicit TLS
  auth: {
    user: "mailkite",        // any username works
    pass: process.env.MAILKITE_API_KEY, // your mk_live_… key
  },
});

await tx.sendMail({
  from: "hello@myapp.ai",    // an address on a verified domain
  to: "ada@example.com",
  subject: "Your invoice #1042",
  html: "<p>Thanks! Receipt attached.</p>",
});

GitHub Docs

settings.py

import os

EMAIL_HOST = "smtp.mailkite.dev"
EMAIL_PORT = 587                     # STARTTLS · 465 for implicit TLS
EMAIL_USE_TLS = True
EMAIL_HOST_USER = "mailkite"         # any username works
EMAIL_HOST_PASSWORD = os.environ["MAILKITE_API_KEY"]  # your mk_live_… key
DEFAULT_FROM_EMAIL = "hello@myapp.ai"  # an address on a verified domain

# Anywhere in your app:
# from django.core.mail import send_mail
# send_mail("Your invoice #1042", "Thanks! Receipt attached.",
#           "hello@myapp.ai", ["ada@example.com"])

GitHub Docs

.env

MAIL_MAILER=smtp
MAIL_HOST=smtp.mailkite.dev
MAIL_PORT=587                    # STARTTLS · 465 for implicit TLS
MAIL_USERNAME=mailkite           # any username works
MAIL_PASSWORD=mk_live_…          # your MailKite API key
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=hello@myapp.ai # an address on a verified domain

# Then Mail::to('ada@example.com')->send(new InvoiceMail) just works.

GitHub Docs

config/environments/production.rb

config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
  address:              "smtp.mailkite.dev",
  port:                 587,                     # STARTTLS · 465 for implicit TLS
  user_name:            "mailkite",              # any username works
  password:             ENV["MAILKITE_API_KEY"], # your mk_live_… key
  enable_starttls_auto: true,
}
# Action Mailer now sends from any address on a verified domain.

GitHub Docs

read_inbox.py

# Read your MailKite inbox from any IMAP client or library — over IMAPS,
# with a scoped app-password (Settings → IMAP), never your API key.
import imaplib

M = imaplib.IMAP4_SSL("imap.mailkite.dev", 993)
M.login("agent@yourdomain.com", "mk_imap_…")  # your IMAP app-password
M.select("INBOX")
typ, data = M.search(None, "UNSEEN")

GitHub Docs

Get your API key Browse the libraries Quickstart

How it works

Live in three steps

No infrastructure, no inbound queue to manage. Connect a domain and point us at a URL.

Point your domain

Add the DNS records we generate for you — MX, SPF, and DKIM. We verify them automatically and flip your address live.

Wire up the webhook & key

Tell MailKite where to POST inbound mail, and grab an API key to send. Any HTTPS endpoint and any stack works.

Send & receive

Inbound arrives as clean JSON at your webhook; outbound goes out with one API call. Same address, both directions.

Features

Ship email features, not a mail server

The plumbing of a mail provider, exposed as a clean developer API.

Email → Webhook

Every message that hits your address is parsed and POSTed to your endpoint as clean JSON — body, headers, and attachments included. No IMAP, no polling, no mail server to babysit. If your endpoint is down, we retry on a backoff schedule and alert you — so you never miss an inbound email.

Send with one API

One endpoint, one API key. Send transactional mail, replies, and broadcasts over your own authenticated, warmed-up domain — built on Cloudflare's edge.

Unlimited domains and mailboxes, free

Spin up as many products as you want, with unlimited mailboxes on every domain. Each domain is free until it has real traction — you only pay once one actually takes off. No per-domain fees, ever.

No mail server, ever

Deliverability, security, and uptime are handled. SPF, DKIM, and DMARC are configured and monitored for you, so your mail lands in the inbox.

Own your data

Flip on zero-retention passthrough and we never store a byte — your webhook keeps the only copy. Or paste a public key and we encrypt every message we retain, so only you can read it.

Read it in any mail client

No server to run — but when a human needs to read along, point Apple Mail, Thunderbird, a phone, or your agent's IMAP library at your inbox over IMAPS. A scoped, revocable app-password, never your API key.

mail servers to run

No MX hosts, no Postfix, no IP warm-up. Point DNS at MailKite and skip the mail server entirely.

API + webhook to integrate

Send with one POST. Every inbound message lands on your webhook as clean, parsed JSON.

∞

domains & mailboxes, free

Give every product its own domain. Pay only when one gets traction — no per-domain fees.

Receive · the payload

One webhook, the whole message

This is exactly what hits your endpoint the moment an email arrives — no MIME wrangling, no encoding surprises.

Plain text and HTML bodies, already decoded
Attachments behind short-lived signed URLs
Stable message IDs for idempotent processing
Full headers when you need them

inbound.json

POST /your/webhook  HTTP/1.1
Content-Type: application/json

{
  "from": "ada@example.com",
  "to": "hello@myapp.ai",
  "subject": "Re: invoice #1042",
  "text": "Looks good — approved!",
  "html": "<p>Looks good — approved!</p>",
  "attachments": [
    {
      "id": "msg_8f3a...:0",
      "filename": "po.pdf",
      "contentType": "application/pdf",
      "size": 18213,
      "url": "https://api.mailkite.dev/att/9f86d0c2"
    }
  ],
  "messageId": "<a1b2c3@mail.example.com>",
  "receivedAt": "2026-06-19T17:42:10Z"
}

send.http

POST /v1/send  HTTP/1.1
Host: api.mailkite.dev
Authorization: Bearer mk_live_3a9f…
Content-Type: application/json

{
  "from": "hello@myapp.ai",
  "to": "ada@example.com",
  "subject": "Your invoice #1042",
  "html": "<p>Thanks! Receipt attached.</p>",
  "attachments": [
    { "filename": "receipt.pdf", "url": "https://…" }
  ]
}

← 202 Accepted
{ "id": "msg_2Hk9…", "status": "queued" }

Send · one API

One API call, delivered

The same address that receives can send. One endpoint, one key — transactional mail, replies, and broadcasts go out over your own authenticated domain, built on Cloudflare's edge.

HTML + text bodies and attachments in one POST
DKIM-signed and aligned automatically — lands in the inbox
Reply in-thread to anything you received
Scoped API keys, idempotent sends

No code to add? Point WordPress, a CRM, or any app that speaks SMTP at our relay →

Works everywhere

Works with every inbox

Mail goes to and arrives from any provider — Gmail, Outlook, and the rest. Keep the inboxes your team already uses; MailKite is the programmable layer on top.

Gmail Outlook Yahoo iCloud Proton Mail Fastmail Zoho Mail Any IMAP / SMTP

Built for agents

Give your agents their own inbox

Every agent gets a real, catch-all inbox — it receives mail sent to any address on the domain and sends from any of them, over MCP, an AI skill, or plain REST. Inbound arrives as structured JSON your agent can reason over.

An inbox per agent

Spin up a fresh address per agent, per task, per tenant — or point a whole domain at one agent. It's a catch-all: mail to any address lands where your agent reads it, and it sends from any of them. Sign-ups, verification, and 2FA codes included — no OAuth, no human in the loop.

MCP-native

In Claude Code, /plugin install mailkite@mailkite and authenticate — no key to copy. Any other client points at the hosted remote server at mcp.mailkite.dev/mcp. Your agent gets tools to send, list, read, and reply — inbound included, which most email MCPs don't expose.

Drop-in AI skill

A published skill wires email into your coding agent in one step — send and act on real inbound without building the plumbing.

Preview

AI on inbound — yours or ours

Received mail arrives as clean JSON your agent acts on and replies to in-thread. Don't want to host a loop? Switch on a built-in inbox agent that triages, replies, filters spam, tags, escalates — and can call any MailKite tool straight from your prompt. No server.

Get an agent inbox See the MCP server AI on inbound →

Scoped access

You decide how much email your agent controls.

Three grants, from the whole account down to a single address — each one revocable on its own.

Account key

Every domain, every mailbox

One key runs all your email: the agent can create domains, set webhooks, send and read everywhere — unlimited domains and mailboxes. For your own trusted automation.

Domain-scoped key

*@agents.yourapp.com

Every mailbox on one domain

The agent sends, reads, and replies on that domain and nothing else — the rest of your account is out of reach. Mint one per agent; revoke one without disturbing the others.

Agent route

support@yourapp.com

One mailbox

A route hands one address's mail to your agent — that inbox is all it sees and all it replies from. The narrowest grant: the agent never holds a key at all.

Set up scoped access →

Why MailKite

Skip the mail server entirely

Without MailKite

Run and patch an IMAP/SMTP server
Poll mailboxes and dedupe by hand
Parse MIME, encodings, and attachments yourself
Fight SPF / DKIM / DMARC for deliverability
Babysit uptime, queues, and storage

With MailKite

Point a domain — 3 records, auto-verified
One webhook receives every message
Clean JSON: text, html, headers, attachments
Auth & alignment configured and monitored
Runs on the edge — nothing to operate

Start shipping email in minutes

Point a domain, drop in a webhook URL, and you're done. Unlimited domains, free to start.

Get started free Read the docs