Tools
Small email tools, most with no sign-up.
Deep email check
Is an email address real? A 0-99 score from its format and the domain's mail records.
Link scanner test
See whether a mail filter opens your sign-in link before the person does.
Sign-in code guess odds
How likely is it that someone guesses a code? Per day, month and year.
Dev mail fence
One send function that keeps staging mail away from real inboxes.
Email router
Email in your app before you own a domain.
One call to sign up, one call to send. No DNS records, no account review, no SMTP server. Your sign-up codes, password resets and alerts go out from yourapp@email59.com while your app is still on a preview address.
Bots and agents can sign themselves up. The MCP server is built in.
No domain, no DNS, no review.
Most email services want a verified domain, SPF and DKIM records and a human review before your first send. Here you pick a name, and mail goes out from that name at email59.com.
Bots sign up on their own.
An agent asks for a code, reads it and gets a key, with no person in the loop. Or it connects to the MCP server at /v1/mcp and calls send_email.
Built for the emails your users count on.
OTP codes, sign-up confirmations, newsletters, and alerts like "your export is ready" or a missed-payment notice.
Code samples
Send your first email.
Each sample makes one HTTPS call to /v1/send with your key in the EMAIL59_KEY environment variable. "from": "yourapp" sends as yourapp@email59.com. Get your key on your account page.
import json, os, urllib.request
req = urllib.request.Request(
"https://email59.com/v1/send",
data=json.dumps({"from": "yourapp", "to": "user@gmail.com",
"subject": "Welcome", "text": "Thanks for signing up."}).encode(),
headers={"Authorization": "Bearer " + os.environ["EMAIL59_KEY"],
"Content-Type": "application/json"},
)
print(urllib.request.urlopen(req).read().decode())
const res = await fetch("https://email59.com/v1/send", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.EMAIL59_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
from: "yourapp",
to: "user@gmail.com",
subject: "Welcome",
text: "Thanks for signing up.",
}),
});
console.log(await res.json());
<?php
$ch = curl_init("https://email59.com/v1/send");
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
"Authorization: Bearer " . getenv("EMAIL59_KEY"),
"Content-Type: application/json",
],
CURLOPT_POSTFIELDS => json_encode([
"from" => "yourapp",
"to" => "user@gmail.com",
"subject" => "Welcome",
"text" => "Thanks for signing up.",
]),
]);
echo curl_exec($ch);
curl_close($ch);
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("EMAIL59_KEY"));
var body = new StringContent(
"""{"from":"yourapp","to":"user@gmail.com","subject":"Welcome","text":"Thanks for signing up."}""",
Encoding.UTF8, "application/json");
var res = await http.PostAsync("https://email59.com/v1/send", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main
import (
"bytes"
"fmt"
"io"
"net/http"
"os"
)
func main() {
body := []byte(`{"from":"yourapp","to":"user@gmail.com","subject":"Welcome","text":"Thanks for signing up."}`)
req, _ := http.NewRequest("POST", "https://email59.com/v1/send", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+os.Getenv("EMAIL59_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer res.Body.Close()
out, _ := io.ReadAll(res.Body)
fmt.Println(string(out))
}
Why "router"
email59 is a router, not a mail server.
We don't run our own mail servers or write our own sending code. email59 takes your send call and routes it to an established sending provider, then adds what small apps and agents need on top: sign-up without a domain, sign-up for bots, an MCP server, unsubscribe links and lists, a blocklist and address checks.
Like other routers, we pass the provider's rate on to you instead of marking it up: paid credits are a one-time purchase, last until used, and there is no subscription. How credits work. More providers can sit behind the same endpoint later; your code keeps calling it unchanged.
How it works
Three calls. No SMTP, no deliverability setup.
Sign in
Sign in with osec.one (email code, Google or Apple) to get your API key. Bots can do the same with one POST. Nothing to set up: mail goes out from email59.com.
Send
Codes and alerts go through /v1/send. Newsletters go through /v1/campaigns. We check every address before it counts against your day.
Watch it work
Every send returns an id. Check your account for what went out today, and keep unsubscribes and blocked addresses in one place.
Features
Small, plain and built for small volume.
One-time codes and alerts
Send OTP codes, transactional alerts and missed-payment notices with one POST. Each one is a plain JSON call.
Lightweight, no SDK
Plain HTTPS and JSON. Use the standard HTTP client in Python, JavaScript, PHP, C# or Go. Nothing to install.
Marketing campaigns
One request sends a campaign to up to 1,000 people. The campaign provider adds the unsubscribe link and handles opt-outs.
Unsubscribe lists
Opt-outs are kept per list or for all lists. Unsubscribed people are skipped on every later campaign.
Blocklist
Block single addresses or whole domains for your account. Blocked recipients never count against your day.
Email validation
Syntax, disposable providers, role addresses such as info@, and whether the domain takes mail (MX).
Mailbox
A real inbox at an email59.com address: read, answer, write and delete on one page, attachments included. Pick an address.
Gmail cleanup
For your own mailbox: find years of old notifications, Promotions and no-reply mail and move them to Trash in one go. Clean up Gmail.
Deep address check
Before you send, check an address in depth: format, provider rules, MX, SPF, DMARC and DKIM, with a score. Try it.
Bot-first API
Plain JSON, bearer keys, OpenAPI at /docs. Agents can sign up, send and check balance themselves.
For bots
Bots welcome. Sign up and start sending on your own.
Every agent, script and CI job can use email59 without a person in the loop: sign up with an email code (or one signup call), get a key, then send. Agents can connect to the MCP server at https://email59.com/v1/mcp. Read llms.txt for a short, machine-friendly description.
POST /v1/auth {email} -> code emailed to you
POST /v1/auth {email, otp} -> {session_key} (new emails are signed up)
POST /v1/send {from, to, subject, text} -> {id, remaining_today}
POST /v1/campaigns {from, subject, html, recipients[]} -> {campaign_id, accepted, rejected}
POST /v1/validate {email} -> {verdict}
GET /v1/account -> {daily_limit, sent_today, remaining_today, credits_remaining}
Articles
Short reads on how email really works.
Eighteen posts with bullet points: the history, the blocklists that decide delivery, spam filters and what they cost, and the numbers.
Start sending in minutes.
No domain to buy first. Sign in, copy a sample and send your first email.