( AI AGENTS )

The email API your agent sets up itself.

Point an agent at Samva and it reads auth.md, connects the hosted MCP server, and works from machine-readable briefs to send its first message. You review what it did instead of wiring the integration by hand.

Start sending Read the docs

( ZERO TO FIRST SEND )

Hand it a brief. It sends unattended.

An agent takes a short task brief, reads the credential guide, connects over MCP, and calls the send tool. The message id and delivery status come back for you to check.

# brief for a coding agent

Read https://samva.app/auth.md, create an API key,
then follow the quickstart to send email.

→ tool samva_messages_send_email
  { to: "ada@example.com",
    subject: "Your code is 391042" }

← result
  { id: "msg_01hv8kq2", status: "queued" }

( THE PROBLEM )

Email APIs were built for a human at a keyboard.

Email APIs expect a person in a dashboard.

Setup assumes someone clicks through a console, copies a key by hand, and reads a getting-started page written for human eyes.

A handed-off credential reaches too far.

A shared password or an over-broad key gives an agent more of your account than the one job you meant to delegate.

Setup docs don't read as instructions.

An agent can't follow a screenshot. Prose written for people leaves the steps for the agent to guess at.

( HOW IT WORKS )

Three steps, and the agent is sending.

#01 — READ

Point it at auth.md.

The agent fetches samva.app/auth.md, a machine-readable guide to the credential types, and picks a scoped API key for unattended work.

GET https://samva.app/auth.md

API key → X-API-Key: samva_sk_live_…
          servers, CI, unattended agents
OAuth → samva login          a human at a terminal
MCP → mcp.samva.app/mcp

#02 — CONNECT

Connect the hosted MCP.

Give an OAuth-capable client the endpoint URL. It runs the OAuth flow, you approve once, and the agent gets email as a set of tools.

{
  "mcpServers": {
    "samva": {
      "type": "http",
      "url": "https://mcp.samva.app/mcp"
    }
  }
}

#03 — SEND

Send the first message.

The agent calls the send tool and gets back a message id and delivery status. You review what it did instead of wiring the integration by hand.

→ samva_messages_send_email
  { to: "ada@example.com", subject: "Welcome aboard" }

← msg_01hv8kq2 · queued

( KEEP READING )

Wire it up from here.

Developers

The typed SDK, REST surface, and auth model in one place.

Transactional email

One typed call for resets, receipts, and one-time codes.

MCP server

Connect an OAuth-capable client and send email as tools.

READ AUTH.MDThe agent setup guide, in plain markdown.

( FAQ )

Questions from engineers.

Can my agent create its own key?

A person creates the first credential: an API key under Developers, API Keys, or a session with samva login. From there the agent holds that credential and can create and rotate more keys through the API keys endpoint. Every key is bound to one organization.

How does MCP OAuth work?

Point an OAuth-capable client at https://mcp.samva.app/mcp with no key. The server answers the first request with the discovery details the client needs, the client runs the OAuth flow, and you approve it once. After that the client acts on your organization.

What tools does MCP expose?

A fixed set: send email, find or create a contact, fetch a message with its delivery status, fetch a conversation, list and test webhook endpoints, and read your usage. The server describes itself on connect, so the agent reads the tool list and an email workflow guide without extra setup.

How do I scope what an agent can send?

Give the agent a key bound to one organization, so it acts inside that tenant and nowhere else. Over MCP the tool set is fixed and narrow, and every action runs against that one organization. Rotate or revoke the key from the dashboard to cut off access.

Get started

Let your agent send its first email.

Create a key, hand it the setup brief, and check what comes back.

Start sending Read the docs