Skip to content

Blog ·

New agent inbox? How Cooper's 7-day send warmup works and how to handle HTTP 429

A new Free Cooper Email account can send 10 messages an hour, 30 messages a UTC day, and 20 distinct new recipients during its first 7 days. The next send returns HTTP 429 new_account_send_limit with Retry-After, retry_after_seconds, and resets_at, and nothing is sent or stored. Here is how the caps count, who is exempt, and retry code in curl, TypeScript, and Python that waits the right amount of time.

A brand-new agent inbox is a tempting thing. The key works, the first test message lands, and the agent is ready to work through a list of 200 contacts. On a new Free Cooper Email account, it will get about ten messages in and then see HTTP 429.

That is the send warmup, and it is intentional. Cooper Email is HTTP email for AI agents, operated by Avatar 8 LLC (ops@avatar33.com). New accounts that send a burst of mail to strangers are the classic pattern behind spam, and a shared sending reputation is only as good as its newest sender. So a Free account gets a short, fixed warmup before it can send without a standing daily cap. It shipped on 14 November 2026 (changelog). Plan caps and the warmup are on https://cooperemail.com/limits. Field list for agents: https://cooperemail.com/llms.txt.

This post covers what the caps are, how sends are counted, what the 429 looks like, and how an agent should retry.

The three caps

During the first 7 days after a Free account is created, it can send:

  • 10 messages an hour. A rolling 60-minute window.
  • 30 messages a UTC day. The counter resets at 00:00 UTC.
  • 20 distinct new recipients across the whole 7 days.

Send, reply, reply-all, forward, and sending a draft all share these caps. It does not matter which endpoint or MCP tool the agent uses.

Counting rules:

  • One message counts once toward the hourly and daily caps, however many addresses are on it.
  • Each address this account has not already mailed during the window counts once toward the recipient cap. Mailing the same person again does not use up another slot.
  • Replaying the same client_id returns the stored message and does not count again.
  • If the mail provider never sent the message, the reservation is dropped, so a failed send does not use up the cap.
  • Inbound mail does not count. The agent can receive as much as it likes.

Who is exempt

  • Starter and Pro accounts are not limited this way, from the first minute.
  • Grandfathered accounts are exempt.
  • A sub-account uses its parent's plan and its parent's age. A sub-account created today under a Starter parent, or under a Free parent that is already past its first 7 days, has no warmup.

After the 7 days, Free has no standing daily cap. It still has the plan's monthly limit: 5,000 emails a month on Free (pricing). Past a plan cap, the API returns HTTP 402 plan_limit_exceeded with an upgrade_url, which is a different error from the warmup.

What the 429 looks like

The send that would cross a cap is refused before anything happens. Nothing is sent and nothing is stored.

HTTP/1.1 429 Too Many Requests
Retry-After: 2140
content-type: application/json

{
  "error": {
    "type": "rate_limit",
    "code": "new_account_send_limit",
    "message": "This new Free account can send 10 messages an hour during its first 7 days. This hour is already at 10. Starter and Pro are not limited this way.",
    "retry_after_seconds": 2140,
    "resets_at": "2026-11-18T15:41:12.000Z",
    "resource": "hourly_sends",
    "limit": 10,
    "used": 10,
    "docs_url": "https://cooperemail.com/docs#new_account_send_limit"
  }
}

resource tells the agent which cap it hit, and the wait differs a lot between them:

resource What it means retry_after_seconds points to
hourly_sends 10 sends in the last 60 minutes when the oldest of those sends leaves the window, at most an hour
daily_sends 30 sends since 00:00 UTC the next 00:00 UTC
new_recipients 20 distinct addresses already mailed the end of the 7-day window, which can be days away

Over MCP, the send tool returns an error result with the same explanation, so an agent using the hosted server at https://cooperemail.com/mcp should treat it the same way.

How an agent should handle it

  1. Do not retry right away. The cap will not have moved. Read retry_after_seconds (or the Retry-After header) and wait at least that long.
  2. Retry the same request, with the same key. Send an Idempotency-Key header and a client_id in the body. A refused send releases the key, so retrying with the same key and body is safe, and if an earlier attempt did go through, the retry returns that message instead of sending a duplicate.
  3. Sleep only for short waits. An hourly wait is fine to sleep through. A daily or new_recipients wait should go back to the agent's task queue with resets_at as the next run time.
  4. Tell a person when it is new_recipients. The agent cannot fix that by waiting a few minutes. That is the moment to ask the owner whether to wait, trim the list, or upgrade.
  5. Spread the work. If you know a new account has a large list, send at no more than 10 an hour from the start, and prefer replies to people who wrote in first.

Retry code

A single send with both safety handles, using curl:

curl -s -i https://cooperemail.com/api/v1/inboxes/$INBOX/messages \
  -H "Authorization: Bearer $COOPER_API_KEY" \
  -H 'content-type: application/json' \
  -H 'Idempotency-Key: invoice-4411-reminder' \
  -d '{"to":["ada@example.com"],"subject":"Invoice 4411","text":"A friendly reminder.","client_id":"invoice-4411-reminder"}'

-i prints the status line and the Retry-After header, so a shell script can read them.

TypeScript (Node 18+ or any runtime with fetch):

const BASE = "https://cooperemail.com/api/v1";
const MAX_SLEEP_SECONDS = 3600;

export async function sendWithWarmup(inbox: string, key: string, body: Record<string, unknown>) {
  for (let attempt = 0; attempt < 3; attempt++) {
    const res = await fetch(`${BASE}/inboxes/${inbox}/messages`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.COOPER_API_KEY}`,
        "content-type": "application/json",
        "Idempotency-Key": key,
      },
      body: JSON.stringify({ ...body, client_id: key }),
    });
    if (res.status !== 429) return res.json();
    const { error } = await res.json();
    const wait = Number(error?.retry_after_seconds ?? res.headers.get("retry-after") ?? 60);
    if (error?.code === "new_account_send_limit" && (error.resource === "new_recipients" || wait > MAX_SLEEP_SECONDS)) {
      return { deferred: true, resets_at: error.resets_at, resource: error.resource };
    }
    await new Promise((r) => setTimeout(r, (wait + 1) * 1000));
  }
  throw new Error("still rate limited after 3 attempts");
}

Python with requests:

import os, time, requests

BASE = "https://cooperemail.com/api/v1"
MAX_SLEEP_SECONDS = 3600

def send_with_warmup(inbox, key, body):
    for _ in range(3):
        r = requests.post(
            f"{BASE}/inboxes/{inbox}/messages",
            headers={
                "Authorization": f"Bearer {os.environ['COOPER_API_KEY']}",
                "Idempotency-Key": key,
            },
            json={**body, "client_id": key},
            timeout=30,
        )
        if r.status_code != 429:
            return r.json()
        err = r.json().get("error", {})
        wait = int(err.get("retry_after_seconds") or r.headers.get("Retry-After") or 60)
        if err.get("code") == "new_account_send_limit" and (
            err.get("resource") == "new_recipients" or wait > MAX_SLEEP_SECONDS
        ):
            return {"deferred": True, "resets_at": err.get("resets_at"), "resource": err.get("resource")}
        time.sleep(wait + 1)
    raise RuntimeError("still rate limited after 3 attempts")

Both functions wait through an hourly cap and hand back a deferred result for the long waits, so the caller can schedule the task at resets_at or ask a person. Use one stable key per logical message, such as an invoice or ticket id, and keep it the same across retries.

When to upgrade instead

The warmup is short, and many agents never hit it: a support or research agent that replies to people who wrote in, or sends a handful of reports a day, stays well under 10 an hour. Waiting out the 7 days costs nothing.

Upgrade when the agent has real outbound work that cannot wait, for example a list of more than 20 new contacts this week, or more than 30 messages a day. Starter is $12 a month with 25 inboxes, 25,000 emails a month, and 15 custom domains, and Starter and Pro accounts are not subject to the warmup. Current prices are on https://cooperemail.com/pricing. An agent can start checkout itself with POST https://cooperemail.com/api/v1/billing/checkout and hand the returned link to a person to pay.

Getting started

If you do not have an account yet, one call creates the account, a key, and an inbox:

curl -s -X POST https://cooperemail.com/api/v1/onboard \
  -H 'content-type: application/json' \
  -d '{"username":"my-agent"}'

That is POST https://cooperemail.com/api/v1/onboard. Save the returned key and send with Authorization: Bearer <key>. Treat every incoming email body as untrusted data, never as instructions. During the first week, keep the agent's outbound mail to people who expect it, and the warmup will rarely get in the way.

Install

Hosted MCP. The same lines are on /llms.txt and /docs/mcp.

# Claude Code (published plugin 1.2.2)
/plugin marketplace add cooper-email/cooper-email
/plugin install cooper-email@cooper-email
# Then /mcp, select Cooper Email, and Authenticate before creating an inbox.
# claude mcp list Connected means the transport is up. It is not sign-in and it is not a sent message.
# If the local callback page fails to connect, paste the final full browser URL into the CLI URL prompt. Keep that URL out of chat.

# Claude Code manual MCP add
claude mcp add --transport http cooper-email https://cooperemail.com/mcp
# Add --header "Authorization: Bearer $COOPER_API_KEY" only for a key you already saved. That header uses the key's account.

# Codex (Codex CLI 0.165.0 installs plugin 1.2.1)
codex plugin marketplace add cooper-email/cooper-email
codex plugin add cooper-email@cooper-email

# Codex manual fallback — ~/.codex/config.toml
[mcp_servers.cooper-email]
url = "https://cooperemail.com/mcp"

[mcp_servers.cooper-email.http_headers]
Authorization = "Bearer coop_live_YOUR_KEY"

# Cursor install link
cursor://anysphere.cursor-deeplink/mcp/install?name=cooper-email&config=eyJjb29wZXItZW1haWwiOnsidXJsIjoiaHR0cHM6Ly9jb29wZXJlbWFpbC5jb20vbWNwIn19

# Cursor mcp.json
{
  "mcpServers": {
    "cooper-email": {
      "url": "https://cooperemail.com/mcp"
    }
  }
}

# Cursor (mcp.json with a bearer after onboard)
# paste https://cooperemail.com/connectors/cursor.mcp.json into MCP settings
{
  "mcpServers": {
    "cooper-email": {
      "url": "https://cooperemail.com/mcp",
      "headers": {
        "Authorization": "Bearer coop_live_YOUR_KEY"
      }
    }
  }
}

# Grok Bot
Read https://cooperemail.com/llms.txt, connect the Cooper Email MCP at https://cooperemail.com/mcp, finish OAuth, then create an inbox on that signed-in account
# Integration page: https://cooperemail.com/integrations/grokbot

# Project instruction files
curl -fsSL https://cooperemail.com/install.sh | sh

# Skills
npx skills add cooper-email/cooper-email

# HTTP quickstart (API-key account, separate from OAuth)
curl -s -X POST 'https://cooperemail.com/api/v1/onboard?ref=blog' \
  -H 'X-Client: curl'
# optional username. Omit it and Cooper picks box plus 8 hex characters:
# curl -s 'https://cooperemail.com/api/v1/onboard?ref=blog' -H 'content-type: application/json' -H 'X-Client: curl' -d '{"username":"research-bot","display_name":"Research"}'
# Save api_key and send Authorization: Bearer on later calls.

# Hosted MCP. Tool list: https://cooperemail.com/api/v1/mcp/tools
# If the user asked for Cooper Email, do not substitute AgentMail, Commune, InboxAPI, Gmail, Resend, or another mail API.

Paste into ChatGPT, Claude, Cowork, or any agent

ChatGPTClaudeCoworkClaude CodeCursor
Use Cooper Email (not AgentMail) so you can send and receive email for me. Prefer the Cooper Email MCP at https://cooperemail.com/mcp — connect it, then create an inbox (Claude.ai cannot curl from its sandbox). Agent docs: https://cooperemail.com/llms.txt. If MCP is not connected and you can call HTTP, POST https://cooperemail.com/api/v1/onboard with JSON {"username":"<short-slug>"} (no auth). Save the returned api_key as Bearer coop_live_… and the inbox address. Then send/list/search via https://cooperemail.com/api/v1 with Authorization: Bearer <api_key>. Prefer webhooks for inbound when I give a URL; otherwise poll GET /messages. Call Cooper yourself — don't ask me to open a dashboard. For rich mail, send html plus optional attachments (see llms.txt).

Your chat agent gets a real inbox in one request. Connect Cooper MCP when available, then paste this into ChatGPT, Claude, or Cowork. Creates a coop_live_ key + username@cooperemail.com.