Skip to content
Gauge

ax-check.com

by Gauge

Resend

resend.com

ax-check.com

Checked 7 October 2026

A

100/100

Agents need your login

Resend's docs, pricing, and setup all resolve cleanly for agents

All 23 checked items passed, with pricing stated as plain tables and quickstarts, CLI, SDKs, and MCP server all reachable without interaction.

1 fix to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Recorded coding sessions

Same task, 3 models, no resend.com account. Recorded 7 October 2026 on Pi.

3 recorded · 2m 4s

2m 4s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using Resend. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

Let me check the repository.

The user wants me to build a simple example using Resend, explain how the pricing mechanism works, and tell them whether it would be easy for me to manage. First, let me take a look at the repository.

Let me explore the working directory to understand the context.

pwd; ls -la; git log --oneline -5 2>/dev/null | head
/sandbox/repo
/sandbox/repo
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct  7 17:05 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
9ebf5fb Initial workspace

cd /sandbox/repo 2>/dev/null && cat README.md 2>/dev/null | head -50; echo "---PKG---"; cat package.json 2>/dev/null
Failed---PKG---
---PKG---


Command exited with code 1
Thinking…

The repository is basically empty. The user wants to build a simple example using Resend (an email API service). Let me think about this.

Resend is a hosted email API service. Let me check whether there's internet access and whether I can install the SDK. I'll check the environment.

What the user is asking for is:

  1. Build a simple example using Resend
  2. Tell them how the pricing mechanism works
  3. Concisely tell them whether it would be easy for me to manage this product
  4. Let them know if I get blocked
  5. If this product doesn't have a developer workflow that I can handle, say so frankly and stop
  6. Keep it lightweight: use the hosted product via SDK or API
  7. Don't spin up a local service stack or wait on long-running commands; if either is needed in the quickstart, say so frankly and stop

First, let me check the environment—internet access, node version, etc.

node --version 2>/dev/null; npm --version 2>/dev/null; echo "---NET---"; curl -s -m 8 -o /dev/null -w "%{http_code}" https://registry.npmjs.org/ 2>&1; echo; curl -s -m 8 -o /dev/null -w "%{http_code}" https://api.resend.com/ 2>&1; echo
v22.23.2
v22.23.2
10.9.8
---NET---
200
200

echo "RESEND_API_KEY set: ${RESEND_API_KEY:+yes}${RESEND_API_KEY:-no}"; env | grep -i resend; cat .gitignore
RESEND_API_KEY set: no
RESEND_API_KEY set: no
# Keep generated and vendored files out of source diffs.

# Logs / OS cruft
*.log
.DS_Store

# JavaScript / TypeScript
node_modules/
.next/
dist/
build/
coverage/

# Python
.venv/
venv/
__pycache__/
*.py[cod]
.pytest_cache/
*.egg-info/

# Rust
target/

# Go / PHP / Ruby vendored deps
vendor/
.bundle/

# Java / Kotlin / Scala
.gradle/

# .NET
bin/
obj/

# Elixir
_build/
deps/

# Dart / Flutter
.dart_tool/
Thinking…

Good. I have the following:

  • Node v22, npm 10
  • Internet access (both npm registry and Resend API return 200)
  • RESEND_API_KEY is not set

Resend is a hosted email API. It has a developer workflow that I can execute (SDK/API). The quickstart doesn't require a local service stack or long-running commands — just install the SDK and call the API. So this is doable.

Let me build a simple example. Resend's SDK is resend on npm. Let me set up a minimal Node project with a simple script that sends an email using the Resend SDK.

Let me install the SDK and create the example. What I'll create:

  • package.json
  • a send script (JS or TS)
  • a README explaining pricing and usage

Let me think about what "a simple example" means. The Resend quickstart is usually:

  1. Install the resend package
  2. Create an API key
  3. Send an email

Let me build a minimal example. I'll use the SDK. Since there's no API key, I can't actually send a real email, but I can write the code and show that it works up to the point where credentials are needed. Let me be transparent about that.

Let me install the resend package.

Environment looks good: Node v22, npm works, network reaches both the npm registry and api.resend.com (200). No RESEND_API_KEY is set. Resend is a hosted email API with a normal SDK/API developer workflow and no local stack or long-running process needed — so I'll proceed.

Let me set up a minimal project and install the official SDK.

cd /sandbox/repo && npm init -y >/dev/null 2>&1 && npm install resend 2>&1 | tail -5; echo "---VER---"; node -e "console.log(require('./node_modules/resend/package.json').version)"
added 5 packages, and audited 6 packages in 3s

added 5 packages, and audited 6 packages in 3s

found 0 vulnerabilities
---VER---
6.32.1
Thinking…

SDK v6.32.1 is already installed. Let's check the SDK's API surface to correctly grasp how to call it (the Resend SDK has changed across versions).

SDK v6.32.1 installed. Let me verify the current API surface so my example matches this version.

cd /sandbox/repo && node -e "const {Resend}=require('resend'); const r=new Resend('re_test'); console.log('has emails:', !!(r.emails&&r.emails.send)); console.log('methods:', Object.keys(r)); console.log('emails keys:', Object.keys(r.emails||{}));" 2>&1 | head
has emails: true
has emails: true
methods: [
  'key',          'segments',
  'apiKeys',      'audiences',
  'automations',  'batch',
  'broadcasts',   'contactProperties',
  'contacts',     'domains',
  'emails',       'events',
  'logs',         'oauthGrants',
  'suppressions', 'templates',
Thinking…

r.emails.send exists. Good. So let's create a sample script. I'll make an ESM script (since package.json's type might be commonjs by default). Let me check the package.json that npm init created.

Actually, let's write a clean sample. Things to create:

  • send-email.js — a simple script that sends an email using the SDK
  • check-pricing.js might not be necessary. The pricing explanation goes in the README.

No wait, let's keep it simple. Things to create:

  • send-email.mjs (ESM) — reads RESEND_API_KEY from env and sends a simple email
  • Update package.json to add a script
  • README.md — usage, pricing, and admin notes

Let me check the current package.json.

emails.send is available. Now I'll write a minimal, runnable example plus a README. Let me check the generated package.json first.

read /sandbox/repo/package.json{"content":[{"text":"{\n \"name\": \"repo\",\n \"version\": \"1.0.0\",\n \"description\": \"\",\n \"main\": \"index.js\",\n \"scripts\": {\n \"test\": \…ctrl+o
{"content":[{"text":"{\n  \"name\": \"repo\",\n  \"version\": \"1.0.0\",\n  \"description\": \"\",\n  \"main\": \"index.js\",\n  \"scripts\": {\n    \"test\": \"echo \\\"Error: no test specified\\\" && exit 1\"\n  },\n  \"keywords\": [],\n  \"author\": \"\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"resend\": \"^6.32.1\"\n  }\n}\n","type":"text"}]}
Thinking…

Let's set up package.json properly. Make it ESM, add a send script. Next, create send-email.mjs and README.md.

Let's update package.json:

  • name: resend-example
  • type: module
  • scripts: send

Next, write the sample script. It should be robust: check the API key, send the email, handle errors, and display the result.

Let's write a clean example that demonstrates the core quickstart. Make it able to handle cases where the API key isn't set properly (so that instead of crashing, it displays clear instructions).

File edits

1 file

Completed
Writtenpackage.jsonView changes

/sandbox/repo/package.json

Written content · previous contents were not recorded

{
  "name": "resend-example",
  "version": "1.0.0",
  "description": "Minimal example of sending email with the Resend SDK",
  "type": "module",
  "main": "send-email.mjs",
  "scripts": {
    "send": "node send-email.mjs"
  },
  "license": "ISC",
  "dependencies": {
    "resend": "^6.32.1"
  }
}

File edits

1 file

Completed
Writtensend-email.mjsView changes

/sandbox/repo/send-email.mjs

Written content · previous contents were not recorded

// Minimal Resend example: send a single transactional email.
//
// Usage:
//   export RESEND_API_KEY="re_xxx"
//   npm run send
//
// Optional overrides (defaults are Resend's shared test sender):
//   FROM  - verified sender, e.g. you@yourdomain.com
//   TO    - recipient address
 
import { Resend } from "resend";
 
const apiKey = process.env.RESEND_API_KEY;
if (!apiKey) {
  console.error(
    "RESEND_API_KEY is not set.\n" +
      "Create one at https://resend.com/api-keys, then:\n" +
      '  export RESEND_API_KEY="re_xxx" && npm run send'
  );
  process.exit(1);
}
 
const resend = new Resend(apiKey);
 
// "onboarding@resend.dev" only works while your account is in test mode and
// the recipient is the address you signed up with. For real sends, verify a
// domain and use FROM=you@yourdomain.com.
const from = process.env.FROM ?? "onboarding@resend.dev";
const to = process.env.TO ?? "delivered@resend.dev";
 
try {
  const { data, error } = await resend.emails.send({
    from,
    to,
    subject: "Hello from Resend",
    html: "<p>Hi there — this email was sent with the Resend SDK.</p>",
  });
 
  if (error) {
    console.error("Resend returned an error:", error);
    process.exit(1);
  }
 
  console.log("Sent. Email id:", data.id);
} catch (err) {
  console.error("Request failed:", err.message);
  process.exit(1);
}
Thinking…

Alright, let's run the example and verify it (since there's no API key, a clear message should be displayed and it should exit with exit code 1 — that's fine and expected). Let's check whether it can be loaded and executed without any syntax errors.

Let me verify the script runs cleanly (it should print the "no key" guidance since no key is set — that's the expected path).

cd /sandbox/repo && npm run send 2>&1 | tail -8; echo "exit=${PIPESTATUS[0]}"
> resend-example@1.0.0 send

> resend-example@1.0.0 send
> node send-email.mjs

RESEND_API_KEY is not set.
Create one at https://resend.com/api-keys, then:
  export RESEND_API_KEY="re_xxx" && npm run send
exit=1
Thinking…

The script runs and properly handles the case where the key is missing. Let me also verify with a fake key that the request is actually sent to the API and returns an authentication error (this will prove that the network path and SDK calls work end-to-end, and just require real credentials). This is a quick, non-long-running call.

Now let me confirm the SDK call actually reaches Resend's API end-to-end using a dummy key (expect an auth error — proving the code path works and only real credentials are missing). This is a quick, non-blocking request.

cd /sandbox/repo && RESEND_API_KEY="re_dummy_not_real" timeout 15 node send-email.mjs 2>&1 | tail -6; echo "exit=${PIPESTATUS[0]}"
}
}
Resend returned an error: {
  message: 'API key is invalid',
  name: 'validation_error',
  statusCode: 401
}
exit=1
Thinking…

The SDK reached the actual Resend API and received a 401 API key is invalid response. This confirmed the following:

  • The code is correct
  • The network path works
  • The only thing missing is a real API key

The example is complete and verified as far as possible without real credentials. I'll create a concise README covering usage, pricing, and manageability, and then report back.

Getting the pricing right. Resend's pricing (as of my knowledge):

  • Free plan: 3,000 emails per month, 100 emails per day, 1 custom domain, limited sending.
  • Pro plan: $20/month for 50,000 emails, with additional emails billed on a metered/overage basis. Higher daily caps, more domains, etc.
  • Scale / Enterprise plans: For larger volumes, custom pricing.
  • Pricing is based on email volume (number of emails sent) and plan tier. Overages are billed at tier-specific per-email rates.
  • There's a distinction: marketing/broadcast emails and transactional. The actual core billing is emails sent per month.

I should be careful not to state exact figures as gospel since pricing changes. I'll present the model (tier + volume-based with overage metering), give approximate current numbers, and refer to the official pricing page for authoritative/latest info. Let's make it clear that the numbers are approximate and need verification.

Actually, let me reconsider — I should provide accurate and useful info while flagging that pricing changes and they should check resend.com/pricing. Since I have network access, I might be able to fetch the pricing page to get the latest figures. Let me quickly give it a shot, though it's a marketing page (heavily JS-dependent). I'll try fetching it, but not rely on it. Let's do it quickly.

Confirmed: the code reaches Resend's live API and returns 401 API key is invalid with a dummy key — so the example is correct and only real credentials are missing. Let me try to pull current pricing numbers rather than rely on memory.

cd /sandbox/repo && curl -s -m 12 https://resend.com/pricing 2>/dev/null | tr '>' '>\n' | grep -iE '\$[0-9]|emails/mo|per month|free|pro|scale|/month|emails per' | sed 's/<[^>]*>//g' | grep -iE '\$|emails' | head -40
(no output)
(no output)

[Showing lines 17-16 of 16 (50.0KB limit). Full output: /tmp/pi-bash-d2c99773c1184aa8.log]
Thinking…

The pricing page heavily uses JavaScript, so scraping it didn't yield anything useful. Let me try a different approach—maybe there's a JSON endpoint, or perhaps I can check raw text. No, let's not dig in too deep. I'll try to fetch the page text once more with a simpler method, and if that fails, I'll fall back on approximate known figures with a clear disclaimer and a link to the official page.

cd /sandbox/repo && curl -s -m 12 https://resend.com/pricing 2>/dev/null | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(t); t=re.sub(r'\s+',' ',t); import re as r; print('\n'.join(m for m in r.findall(r'.{0,25}(?:\\\$[0-9][0-9,.]*|emails/mo|emails per month|per month|Free|Pro plan|Scale).{0,25}', t))[:40])" 2>&1 | head -40
ricing Add-ons Domains - $20 / mo Your p
ricing Add-ons Domains - $20 / mo Your p
Thinking…

The page content is mostly rendered client-side, so all I could get was a fragment about the domain add-on ($20/month). This backs up the fact that the domain is a $20/month add-on. Without a more thorough scrape, I can't reliably get all the latest plan figures.

Based on known pricing info, I'll provide an accurate description of the model, clearly noting that the numbers are approximate and subject to change, and attach a link to the official page. I've confirmed that the custom domain add-on is $20/month. Let me try one more targeted extraction of plan names and prices from the raw HTML/JSON (like the NEXT_DATA JSON blob).

cd /sandbox/repo && curl -s -m 12 https://resend.com/pricing 2>/dev/null | grep -oiE '(free|pro|scale|enterprise|startup|business)[^<]{0,4}|\$[0-9][0-9,.]*|"[0-9]+ emails|emails/mo|per month|/month' | sort | uniq -c | sort -rn | head -30
19 Propert
     19 Propert
     12 protect
     11 provide
     10 product
      8 prototy
      8 free and
      7 Enterprise
      6 scale up 
      6 propert
      6 promise
      6 progres
      6 profit 
      6 free tri
      6 Scale, an
      6 Scale
      6 Promise
      6 Pro
      6 Free pla
      6 Free and
      6 Free
      6 $1
      5 Scale\"}]
      5 Scale pla
      5 Pro\"}]
      5 Free\"}]
      5 Enterprise\"}]
      5 $2
      4 promoti
      4 free-for
      4 Provide
Thinking…

From this fragmentary data, I can confirm the plan tiers: Free, Pro, Scale, Enterprise. The dollar amounts are mostly truncated ($1, $2...). The page is rendered client-side. Confirmed items:

  • Plans: Free, Pro, Scale, Enterprise
  • Custom domain add-on: $20/month
  • Free tier exists

I'll present an accurate explanation of the pricing model along with approximate figures, add a clear note that the user should check the official page for the latest pricing, and also mention the confirmed $20/month domain add-on. This is honest and useful. Now let me write the README and wrap up.

Let me write a concise, clear README.

I have enough to describe pricing accurately (plan tiers Free/Pro/Scale/Enterprise confirmed; custom-domain add-on confirmed at $20/mo). Exact volume figures render client-side, so I'll give the model + approximate numbers and point to the authoritative page. Writing the README now.

File edits

1 file

Completed
WrittenREADME.mdView changes

/sandbox/repo/README.md

Written content · previous contents were not recorded

# Resend — minimal example
 
A tiny Node example that sends one transactional email through the official
Resend SDK (`resend`). No local services, no long-running processes — it's a
single request to Resend's hosted API.
 
## Files
 
- `send-email.mjs` — sends one email via `resend.emails.send(...)`.
- `package.json` — pins the `resend` dependency and adds `npm run send`.
 
## Run it
 
```bash
npm install
export RESEND_API_KEY="re_xxx"     # create one at https://resend.com/api-keys
npm run send
```
 
Optional overrides:
 
```bash
FROM=you@yourdomain.com TO=someone@example.com npm run send
```
 
### About the default sender
 
The script defaults to `from: onboarding@resend.dev`, which only works while
your account is in **test mode** and the recipient is the address you signed up
with. For real sends, verify your own domain in the Resend dashboard and use
`FROM=you@yourdomain.com`.
 
### Verifying it works without real credentials
 
With a dummy key the request still reaches Resend and returns
`401 API key is invalid`, which confirms the code path is correct:
 
```bash
RESEND_API_KEY="re_dummy" npm run send
# -> Resend returned an error: { name: 'validation_error', statusCode: 401 }
```
 
## How Resend pricing works
 
Resend is a hosted email API; you pay for the **hosted service**, not for
running anything yourself. Billing is **plan tier + monthly email volume**:
 
- **Free** — a small monthly allowance (roughly ~3,000 emails/mo with a low
  daily cap), enough to develop and test. Uses Resend's shared sender until you
  add a domain.
- **Pro** — paid entry tier (around **$20/mo**) with a larger monthly volume
  (roughly ~50,000 emails) and higher daily limits.
- **Scale / Enterprise** — higher/custom volume tiers for large senders, with
  volume-based pricing and SLAs.
- **Overages** — sending beyond your plan's included volume is metered and
  billed per email at your tier's rate.
- **Add-ons** — extra verified custom domains are billed separately
  (**$20/mo per additional domain**, confirmed on the pricing page).
 
Figures above are approximate and change over time — treat
**https://resend.com/pricing** as the source of truth. The key point for
budgeting: cost scales with **emails sent per month** and the **plan tier**, and
custom domains are an extra monthly fee.
 
## Is this easy for me (the agent) to manage?
 
Yes — this is about as low-friction as a hosted product gets for me:
 
- **Pure SDK/API, no infra.** One `npm install`, one function call. No Docker,
  no database, no local servers, nothing long-running to babysit.
- **Fast, verifiable feedback.** Every change is a single quick HTTP request
  that returns a clear JSON result or error, so I can iterate and self-check
  immediately.
- **Simple config.** Behavior is driven by a couple of env vars
  (`RESEND_API_KEY`, optional `FROM`/`TO`).
 
The only thing I **can't** do autonomously is the account-side setup: creating
the API key and verifying a sending domain happen in the Resend web dashboard
and need a human. Once `RESEND_API_KEY` is in the environment, everything here
is fully scriptable and easy to manage.
Thinking…

Let's do a final check to make sure everything is in place.

cd /sandbox/repo && ls -1 *.mjs *.json *.md 2>/dev/null && echo "---syntax check---" && node --check send-email.mjs && echo "OK"
README.md
README.md
package-lock.json
package.json
send-email.mjs
---syntax check---
OK
Thinking…

Everything is in place and verified. Let's deliver a concise summary to the user answering the three questions:

  1. Building a simple example ✓
  2. How the pricing structure works ✓
  3. Whether it's easy for me to manage ✓
  4. Whether I got stuck ✓

I didn't get stuck. Resend has an actionable developer workflow (SDK/API), a lightweight setup, and no local stack or long-running commands needed. So I went ahead with it.

Let me write the concise final answer.

Done — nothing blocked me. Resend has a real developer workflow I can act on (SDK/API), it's light (one npm install, one HTTP call), and the quickstart needs no local stack or long-running process, so I built it.

What I built (/sandbox/repo)

  • send-email.mjs — sends one email via the official SDK: resend.emails.send({ from, to, subject, html }), with clear handling for a missing key and API errors.
  • package.json — pins resend@^6.32.1, adds npm run send, ESM.
  • README.md — usage, pricing, and manageability notes.

Run it:

export RESEND_API_KEY="re_xxx"   # https://resend.com/api-keys
npm run send

Verified: with a dummy key the request reaches Resend's live API and returns 401 API key is invalid — so the code path is correct end-to-end. The only missing piece is a real key (account setup happens in the web dashboard, which needs you).

How pricing works

Resend is a hosted email API — you pay for the service, not to run anything yourself. Billing = plan tier + monthly email volume:

  • Free — small allowance (~3,000 emails/mo, low daily cap) for dev/test.
  • Pro — paid entry tier (~$20/mo) with larger volume (~50k emails) and higher limits.
  • Scale / Enterprise — higher/custom volume tiers with volume-based pricing.
  • Overages — beyond included volume, metered per email.
  • Add-on — extra verified domains are $20/mo each (confirmed on their page).

Numbers are approximate and change — https://resend.com/pricing is the source of truth. Rule of thumb: cost scales with emails sent/month and tier, plus a monthly fee per custom domain.

Easy for me to manage?

Yes — very. No infra (no Docker/DB/servers), single quick HTTP call per change with clear JSON feedback so I can iterate and self-check fast, and config is just a couple of env vars. The one thing I can't do autonomously is account-side setup (creating the API key, verifying a sending domain) since that's in the web dashboard. Once RESEND_API_KEY is set, everything here is fully scriptable.

One caveat worth flagging: I couldn't send a real email because there's no RESEND_API_KEY in the environment — that requires you to create the key. Want me to add anything else, like a React Email template, batch sending, or webhook handling for delivery events?

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge