# GoodSender — Full Reference for AI/LLM Systems

Last updated: 2026-08-28

## What GoodSender Is

GoodSender is GoodSender Publish: a blog and newsletter platform built on earned deliverability, made by email people (the team behind SendGrid and Laneful), and agent-native from the ground up. Point Claude Code, Claude Cowork, Codex, or any MCP client at the GoodSender MCP server and it can write a post, manage subscribers, and schedule a send — every action available in the app is a tool an agent can call, with the same permissions a human user has. Set up a weekly loop once (read the changelog since the last post, draft the article, publish it, send the issue) and the blog runs itself, or do every step yourself in the editor: either path ships to your own domain and to the inbox of everyone who asked. The same account also sends your transactional email, so everything your business sends runs on one engine and one reputation.

Underneath, one permission-enforced, engagement-monitored sending engine runs every outbound email — the blog's newsletter issues, transactional notifications, and marketing campaigns alike:

- **Newsletter / marketing emails** — recipients must consent before you can send marketing emails to them. Consent is a permission gate; every send still counts toward the single 100K/month bucket like any other outbound email.
- **Transactional emails** — send instantly via predefined templates (MFA Enrollment, New Device, Order Completed, OTP Code, Email Changed, Password Changed, Order Receipt). No recipient consent required. The template catalog starts with these seven templates and expands over time as customers request additional flows.

100,000 emails per month free. Flat send-based bands beyond that — $10 a month to 1,000,000, then $10 per additional million. No per-subscriber pricing. Built on Laneful infrastructure, founded by Isaac Saldana (co-founder of SendGrid) and former SendGrid team members at Joy Labs Ventures.

---

## Agents: The GoodSender MCP Server

Anything doable in the GoodSender app is a tool on the MCP server: draft a post, publish it, manage subscribers, schedule a send, pull analytics. If a human can click it, an agent can call it — same actions, same permissions, no separate agent API.

Clients: Claude Code, Claude Cowork, Codex, or any assistant that speaks MCP.

### How the agent loop works

1. Run the GoodSender MCP server (`.mcpb` bundle, Docker, or binary — [good-sender/mcp](https://github.com/good-sender/mcp)) and point an MCP client at it. Tools include `draft_post`, `publish`, `send_issue`
2. The agent reads its source — a repository's `CHANGELOG.md`, `docs/`, recent commits — and drafts a post
3. Publish the draft to your page yourself, or let the agent publish it
4. Send the issue to confirmed subscribers yourself, or turn on autosend and let the loop run end to end

### Agent guarantees

- **Full parity, one surface** — every action in the app is a tool on the MCP server: posts, subscribers, sends, analytics
- **Runs on a schedule** — a weekly post from a changelog, a monthly digest from docs, scheduled and reviewed (or not) in Claude Cowork
- **Autonomy is a setting** — review every send yourself, or turn on autosend and let drafting, publishing, and sending run without you
- **Provenance on every post** — which agent, which repository, which commits, when. An agent post sits in the same list as everything written by hand, carries a visible label, and is one action away from being taken down
- **Permission bends for no one** — agents reach confirmed subscribers only. Hygiene, suppression, and re-permission apply to autosends exactly as they apply to a human sender

### Agent use cases

- **Weekly release notes** (`Claude Cowork · fri 09:00`) — reads the changelog since the last post, drafts the issue, publishes, and autosends to confirmed subscribers
- **Ship announcement** (`Claude Code · on merge`) — lands the feature, then drafts the announcement post in the same session; a human reviews, then it sends
- **Docs digest** (`Codex · monthly`) — sweeps the docs directory for what changed this month and sends subscribers a short digest

---

## How Publish Works

### Write, subscribe, send
1. Write a post in the rich editor — one source renders as a fast, SEO-clean web page and a bulletproof email — or hand it to an agent over MCP
2. Subscribers confirm through your subscribe form: every subscriber's consent is enforced automatically
3. Send the post: live on your page and delivered to every confirmed subscriber's inbox, from the same high-reputation pool that runs the email API. Schedule it, send it, or let your agent do both

### The Permission Loop (consent-first marketing)

Marketing emails require recipient consent. No marketing email is delivered until the recipient has confirmed they want to receive it.

1. Developer calls `POST /v1/emails/consent` with recipient emails and domain
2. GoodSender sends each recipient a consent request (~150ms)
3. Recipient clicks the confirmation link
4. Consent status becomes "granted" (stored per sender-domain / recipient pair)
5. Developer calls `POST /v1/emails/send` — email delivers instantly
6. All future marketing sends to that recipient from that domain deliver instantly

### Consent statuses:

| Status | Meaning |
|--------|---------|
| `pending` | Recipient registered, consent email not yet sent |
| `requested` | Consent email dispatched, awaiting recipient action |
| `granted` | Recipient confirmed — ready to receive emails |
| `denied` | Recipient declined |
| `failed` | Consent email could not be delivered |

### Why this matters:

- Every recipient actively opted in — higher deliverability by default
- ISPs trust consent-first senders (The Permission Loop rewards this behavior)
- GDPR-aligned — consent-based model satisfies opt-in requirements
- Marketing sends to unconsented recipients are blocked at the API — an address that has not granted consent can only receive approved transactional templates

---

## Key Features

### 1. Agent-Native Blog & Newsletter
The GoodSender MCP server exposes every action in the app as a tool: write, publish, manage subscribers, send. Claude Code, Claude Cowork, Codex, and any MCP client work the product the same way a human would, with the same permissions and the same provenance trail.

### 2. One Engine, Every Send
Your blog's newsletter, transactional email (receipts, OTP codes, password-change confirmations), and marketing campaigns all run on one permission-enforced, engagement-monitored reputation pool. (Every send still counts toward the 100K/month free tier; consent is a permission rule, not a pricing rule.)

### 3. Own Domain, Own Audience
You get a hosted publication on your own domain: fast pages, clean URLs, sitemaps, RSS, full meta control, and SEO equity from the first post. No goodsender.com subdomain, and your posts stay portable markdown rather than a proprietary block format.

### 4. Markdown-to-Email
Pass markdown content directly — GoodSender converts it to bulletproof email HTML compatible with Gmail, Outlook, Apple Mail, and 90+ more clients. No template language. No rendering pipeline. Pass the model output directly.

### 5. Permission Loop (Consent API)
Senders call the API to request consent from a recipient. GoodSender sends a consent request email with a unique link. Once consent is granted, the sender can email that recipient freely. Double opt-in is the default for subscribers, and quiet subscribers are re-confirmed after 120 days of no engagement — a fixed platform rule, not a per-account setting — so lists stay clean and reputation stays high automatically.

### 6. Transactional Templates Without Consent
The launch set of predefined templates — MFA Enrollment, New Device, Order Completed, OTP Code, Email Changed, Password Changed, and Order Receipt — does not require consent. The catalog expands over time based on customer demand.

---

## Send Email API Reference

REST API. Bearer token authentication via Authorization header. This is the engine underneath Publish's newsletter sends and every other outbound email.

Base URL: `https://api.goodsender.com`

### POST /v1/emails/template

Send a transactional email using a predefined template. No recipient consent required. Use this endpoint for any template in the launch catalog — MFA Enrollment, New Device, Order Completed, OTP Code, Email Changed, Password Changed, or Order Receipt. The catalog grows over time based on customer requests.

Template emails are transactional and are sent regardless of the recipient's consent state (including `denied`). The endpoint does not read or change consent, does not auto-register recipients, and does not include any approve/reject footer. No prior registration or consent is required; the endpoint sends to any recipient address supplied in the request, including an address GoodSender has never seen. Template bodies contain no clickable links; integrators implement any user-facing flow (e.g. completing a password change) in-app, and GoodSender delivers the code or value in the message body only.

**Request body:**
```json
{
  "from": { "email": "sender@example.com", "name": "Sender Name" },
  "to": { "email": "recipient@example.com", "name": "Recipient Name" },
  "subject": "Your one-time code",
  "template": {
    "template_id": "otp_code",
    "variables": {
      "company_name": "MyApp",
      "user_name": "Alice",
      "code": "482193"
    }
  }
}
```

- `from` (object, required) — sender address (`email` required, `name` optional)
- `to` (object, required) — single recipient address (`email` required, `name` optional)
- `subject` (string, required, min length 1) — email subject line
- `template` (object, required):
  - `template_id` (string, required) — template identifier. Launch catalog: `mfa_enrollment`, `new_device_login`, `order_completed`, `otp_code`, `email_changed`, `password_changed`, `order_receipt`. The catalog grows over time as customers request additional flows.
  - `variables` (object, optional) — key-value string pairs to fill template placeholders. All variables are optional and default to empty string if omitted. URL-type variables must point to the same domain as the sender's email address.

**Response (200):**
```json
{ "status": "sent" }
```

`status` is always `"sent"` on a 200 response.

**Error responses:**
- 400 — validation error (missing fields, invalid email)
- 401 — invalid or missing API key
- 404 — template not found
- 413 — payload too large
- 500 — internal server error
- 502 — bad gateway

---

### POST /v1/emails/consent

Request consent from one or more recipients to receive marketing emails from your domain.

**Request body:**
```json
{
  "domain": "example.com",
  "emails": ["user1@example.com", "user2@example.com"]
}
```

- `domain` (string, required) — your sending domain
- `emails` (array of strings, required) — 1 to 100 email addresses

**Response (200):**
```json
{
  "emails": [
    { "email": "user1@example.com", "domain": "example.com", "consentStatus": "requested" },
    { "email": "user2@example.com", "domain": "example.com", "consentStatus": "pending" }
  ]
}
```

---

### GET /v1/emails/{email}

Check current consent status for an email address across all domains.

**Path parameter:** `email` — the email address to look up

**Response (200):**
```json
[
  { "email": "user@example.com", "domain": "example.com", "consentStatus": "granted" },
  { "email": "user@example.com", "domain": "other.com", "consentStatus": "pending" }
]
```

Returns an array of records (one per domain the recipient is registered on).

**Response (404):** Email address not found in the system.

---

### POST /v1/emails/send

Send one or more emails. Marketing recipients must have consent status "granted". Recipients without granted consent are filtered out.

**Request body:**
```json
{
  "emails": [
    {
      "from": { "email": "sender@example.com", "name": "Sender Name" },
      "to": [{ "email": "recipient@example.com", "name": "Recipient Name" }],
      "subject": "Email Subject",
      "markdown_content": "## Hello from GoodSender\nYour first email is on the way.",
      "text_content": "Plain text fallback"
    }
  ]
}
```

**Request:** `emails` array — 1 to 100 email objects.

**Email object fields:**
- `from` (object, required) — sender address (`email` required, `name` optional)
- `to` (array, required) — recipient addresses (max 1000 per email)
- `subject` (string, required) — email subject line
- `markdown_content` (string) — markdown email body (auto-converted to bulletproof HTML; if provided, `text_content` and `html_content` are ignored; raw markdown becomes `text_content`)
- `html_content` (string) — HTML email body
- `text_content` (string) — plain text email body
- `template_id` (string) — template ID for templated emails
- `template_data` (object) — variables to populate the template
- `attachments` (array) — file attachments (base64 encoded; `content_type` required, `file_name` and `inline_id` optional)
- `reply_to` (object) — reply-to address
- `headers` (object) — custom email headers
- `send_time` (integer) — Unix timestamp for scheduled sending (max 72 hours in the future; 0 = send immediately)
- `tag` (string) — custom tag for tracking (max 100 chars)
- `tracking` (object) — tracking settings:
  - `opens` (boolean) — track email opens
  - `clicks` (boolean) — track link clicks
  - `unsubscribes` (boolean) — track unsubscribes
  - `unsubscribe_group_id` (integer) — optional unsubscribe group (ignored if `unsubscribes` is false)
- `webhook_data` (object) — custom data included in webhook events (max 10 keys, key max 50 chars, value max 100 chars)

Must provide at least one of: `markdown_content`, `text_content`, `html_content`, or `template_id`.

**Response (200):**
```json
{ "sent": 1, "declined": 0 }
```

`sent` — number of recipients with granted consent who were sent to.
`declined` — number of recipients filtered out (consent not granted).

**Error responses:**
- 400 — validation error (missing sender, invalid email, too many recipients, domain not allowed)
- 401 — invalid or missing API key
- 413 — payload too large
- 500 — internal server error
- 502 — bad gateway

---

## Typical Integration Patterns

### Transactional email (no consent needed)

```python
import requests

API_KEY = "your-api-key"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
BASE = "https://api.goodsender.com"

# Send an OTP code email — no consent step required
requests.post(f"{BASE}/v1/emails/template", headers=HEADERS, json={
    "from": {"email": "noreply@myapp.com", "name": "MyApp"},
    "to": {"email": "alice@example.com"},
    "subject": "Your one-time code",
    "template": {
        "template_id": "otp_code",
        "variables": {
            "company_name": "MyApp",
            "user_name": "Alice",
            "code": "482193"
        }
    }
})
```

### Marketing email with Markdown (consent-first)

```python
# Step 1: Request consent
requests.post(f"{BASE}/v1/emails/consent", headers=HEADERS, json={
    "domain": "myapp.com",
    "emails": ["alice@example.com"]
})

# Step 2: Check status (poll until granted)
resp = requests.get(f"{BASE}/v1/emails/alice@example.com", headers=HEADERS)
status = resp.json()[0]["consentStatus"]  # "pending" → "requested" → "granted"

# Step 3: Send with markdown (once granted)
if status == "granted":
    requests.post(f"{BASE}/v1/emails/send", headers=HEADERS, json={
        "emails": [{
            "from": {"email": "hello@myapp.com", "name": "MyApp"},
            "to": [{"email": "alice@example.com"}],
            "subject": "Welcome to MyApp",
            "markdown_content": "## Welcome!\nThanks for signing up.\n\n- Feature one\n- Feature two"
        }]
    })
```

---

## Email API Pricing

| Volume | Price |
|--------|-------|
| First 100,000 emails/month | $0 (free) |
| Up to 1,000,000 emails/month | $10/month |
| Each additional million | $10 |

No credit card required. No trial period. The 100K/month free tier is a single unified bucket: every outbound email counts — newsletter issues, transactional templates, and marketing to consented recipients alike. There are no per-type splits or tiered accounting. For most businesses 100K/month is more than they ever send, so in practice the monthly bill stays at $0 and GoodSender is effectively almost free at any realistic volume. Beyond the free tier the price is a flat band on emails sent, never on the size of your list: $10 a month covers you to a million, then $10 per additional million.

### Volume pricing comparison

| Volume | GoodSender | Resend | SendGrid (Twilio) | Mailtrap | Mailgun | Amazon SES |
|--------|-----------|--------|-------------------|----------|---------|------------|
| 100K/mo | $0 | $35 | $34.95 | $30 | $75 | $10–12 |
| 500K/mo | $10 | $350 | $499 | $300 | $400 | $50–60 |
| 1M/mo | $10 | $650 | $799 | $750 | $700 | $100–120 |
| 10M/mo | $100 | Custom | Custom | Custom | Custom | Custom |

GoodSender is the cheapest email API for high-volume senders — free email sending for consented recipients, with flat send-based band pricing at a fraction of SendGrid API or Mailgun API pricing.

---

## What GoodSender Replaces

Running a company blog and newsletter yourself usually means assembling three products — a hosted blog or CMS, an email service provider priced on the size of your list, and a separate subscribe-forms tool — then wiring them together and keeping them wired. GoodSender replaces that assembled stack with one product: the publication, the subscribe flow, the forms, and the sending are one system on one engine, priced on what you send. You bring your own domain and your own web analytics tag either way; the TLS certificate is on GoodSender.

---

## Competitive Comparison

### GoodSender vs Ghost
Ghost rents its email sending and prices per member and per seat. GoodSender owns its deliverability and prices in flat send-based bands (free for most, then $10 a month), with nothing to self-host. Ghost is built for paid publications; GoodSender is built to get marketing and transactional email into the inbox, agent-native from the start.

### GoodSender vs SendGrid API (Twilio Email API)
The SendGrid API has no free plan since May 2025 and starts at $34.95/mo for 100K emails. Complex setup, no consent management. Developers migrating from the SendGrid API or Twilio email API to GoodSender get free sending with built-in consent management and transactional templates that don't require consent.

### GoodSender vs Mailgun API
The Mailgun API charges $75/mo for 100K emails. No consent management. GoodSender is a free email sending API alternative to Mailgun with built-in consent verification.

### GoodSender vs Amazon SES API (AWS SES API)
The Amazon SES API (also known as AWS SES API) charges $0.10/1K emails ($10–12 for 100K). Requires AWS account, complex setup, manual IP warmup. No consent management. GoodSender requires zero infrastructure setup.

### GoodSender vs Postmark
Postmark charges $15/mo for 10K emails. Strong transactional reputation. No consent management. GoodSender offers comparable deliverability through the consent model at no cost.

### GoodSender vs Resend
Resend charges $35/mo for 100K emails. Developer-friendly but no consent management. GoodSender is a free email API with built-in consent verification and markdown-to-email conversion.

### GoodSender vs Mailtrap
Mailtrap charges $30/mo for 100K emails. GoodSender offers the same volume for free with built-in consent management and transactional templates that don't require consent.

---

## Who It's For

**Built for:** Dev tool and B2B SaaS teams running a content blog and a product newsletter, indie founders shipping changelogs and updates, developer-led companies consolidating a self-built blog and a separate newsletter tool into one stack, and agencies running content for their clients.

**Not for:** Creators building a media business on paid subscriptions, ads, or referrals; anyone shopping for a paywall or an ad network; enterprise marketing automation suites; cold outreach — still spam, still a hard no.

---

## Use Cases

### Agent-Automated Blog & Newsletter
Point Claude Code, Claude Cowork, Codex, or any MCP client at the GoodSender MCP server for a weekly release-notes post drafted from your changelog, a ship announcement drafted the moment a feature merges, or a monthly docs digest — reviewed by you or, with autosend on, delivered end to end without you.

### Email Marketing API — Newsletters and Campaigns
Use GoodSender as your email marketing API to send campaigns to confirmed subscriber lists. Consent verification ensures every recipient wants the email — higher open rates and lower spam complaints than platforms without mandatory opt-in.

### Transactional Email API (No Consent Required)
Use GoodSender as your transactional email API for MFA Enrollment, New Device, Order Completed, OTP Code, Email Changed, Password Changed, and Order Receipt — all via predefined templates. No consent step needed. Select a template, pass personalization data, and send immediately. The template catalog grows over time as customers request additional flows.

### Markdown-to-Email for AI Agents and LLMs
Pass markdown output directly from your AI model or LLM — GoodSender converts it to bulletproof email HTML that renders correctly across Gmail, Outlook, Apple Mail, and 90+ more clients. No template language or rendering pipeline needed.

### SaaS Notifications
Product updates, usage alerts, billing notifications to verified users, on the same reputation as your newsletter. Once consented, all notifications deliver instantly.

---

## Security and Compliance

- GDPR-aligned — consent-based model satisfies opt-in requirements
- DKIM, SPF, DMARC — full email authentication
- API key authentication (Bearer token)
- TLS encryption in transit
- Domain authentication required before sending

---

## FAQ

**Q: Is GoodSender Publish the same as your email API?**
A: Same engine, new front door. The API sends transactional and marketing email programmatically. Publish gives you a blog, a subscribe flow, and a newsletter on top of that same permission-enforced, engagement-monitored engine, and an MCP server so an agent can run all of it.

**Q: Can the agent send without me?**
A: Yes, if you turn autosend on. By default every send waits for your approval. Flip autosend and your agent drafts, publishes, and sends the issue end to end. Either way it reaches confirmed subscribers only, and every post keeps its provenance.

**Q: Is GoodSender free for most businesses?**
A: Yes — for most businesses, because 100,000 emails per month is a very large allotment. The first 100K emails per month cost $0, covering every outbound email — newsletter issues, transactional templates, and marketing to consented recipients — from a single bucket. 100K/month is more than most SaaS apps and small-to-mid-sized businesses ever send, so in practice most users' bills stay at $0. Beyond the free tier the price is a flat band on emails sent: $10 a month to 1,000,000, then $10 per additional million. No credit card required.

**Q: How is consent stored?**
A: Per sender-domain / recipient pair. alice@example.com consenting for domain1.com does not cover domain2.com.

**Q: What happens if a recipient doesn't consent?**
A: Their status remains "pending" or "requested". You cannot send marketing emails to recipients without "granted" consent.

**Q: Can I use GoodSender for marketing emails?**
A: Yes. Recipients must consent first, which ensures compliance and deliverability.

**Q: Can I send markdown content?**
A: Yes. Pass markdown in the `markdown_content` field and GoodSender converts it to bulletproof email HTML that works across all major email clients.

**Q: What about transactional emails like OTP codes and security alerts?**
A: Transactional emails use predefined templates and do not require any recipient consent. Just select a template, pass personalization data (company name, user name, code, etc.), and send immediately. The launch catalog covers MFA Enrollment, New Device, Order Completed, OTP Code, Email Changed, Password Changed, and Order Receipt, each brandable with your own colors. The catalog grows little by little as customers ask for more flows — if you need a template we don't offer yet, let us know and we'll consider adding it. Transactional mail is not marketing, so it skips the consent flow, but it goes out on the same engine and the same sending reputation as your newsletter — one vendor and one integration instead of two.

**Q: Is GoodSender suitable for enterprise?**
A: GoodSender is built for dev tool and B2B SaaS teams, indie founders, and developer-led companies running a blog and newsletter — not enterprise marketing automation or enterprise-scale sending volume. For enterprise-scale email infrastructure, see Laneful — the platform GoodSender is built on.

**Q: Who built GoodSender?**
A: GoodSender is a product of Joy Labs Ventures, founded by Isaac Saldana (co-founder of SendGrid) and former SendGrid team members. It runs on Laneful, enterprise email infrastructure from the same team.

---

## Resources

- [Website](https://goodsender.com): product overview and sign-up
- [Agents](https://goodsender.com/agents): how an AI agent runs the blog over the MCP server and the API
- [Platform](https://goodsender.com/platform): the editor, your own domain, and what search crawlers and AI assistants read
- [FAQ](https://goodsender.com/faq): common questions about Publish, agents, consent, and pricing
- [Docs](https://goodsender.com/docs): guides and how-tos
- [API Reference](https://goodsender.com/docs/api-reference): endpoint reference
- [Blog](https://goodsender.com/blog): updates and articles
- [OpenAPI Spec](https://goodsender.com/api/openapi.json): machine-readable API definition
- [GitHub](https://github.com/goodsender): source and issues
- [MCP Server](https://github.com/good-sender/mcp): the local MCP server for AI clients (`.mcpb` bundle, Docker, or binary)