Provides tools for listing and retrieving items from the Resend API, enabling AI assistants to manage Resend data.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@resend list my recent emails"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server that provides access to the Resend API, allowing AI assistants to interact with Resend data.
List and retrieve items from the Resend API
Async HTTP client with error handling
Typed responses with Pydantic models
Related MCP server: Resend MCP Server
# Configure your API key
mpak config set @joecardoso13/resend api_key=your_api_key_here
# Run the server
mpak run @joecardoso13/resend# Clone the repository
git clone https://github.com/JoeCardoso13/mcp-resend.git
cd mcp-resend
# Install dependencies with uv
uv sync
# Set your API key
export RESEND_API_KEY=your_api_key_here
# Run the server
uv run python -m mcp_resend.serverCreate a new API key
Copy the key
Add to your ~/.claude/settings.json:
{
"mcpServers": {
"resend": {
"command": "mpak",
"args": ["run", "@joecardoso13/resend"]
}
}
}Tool | Description |
| List items from the API with optional limit |
| Get a single item by its ID |
# Install dev dependencies
uv sync --dev
# Run tests
uv run pytest tests/ -v
# Format code
uv run ruff format src/ tests/
# Lint
uv run ruff check src/ tests/
# Type check
uv run ty check src/
# Run all checks
make checkMIT
Create a new contact.
| Name | Required | Description | Default |
|---|---|---|---|
| Yes | Contact's email address | ||
| last_name | No | Last name | |
| first_name | No | First name | |
| unsubscribed | No | If true, contact won't receive broadcasts |
| Name | Required | Description |
|---|---|---|
| id | Yes | Contact ID |
| object | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that this is a create operation, but doesn't explain permission requirements, duplicate handling, or side effects such as sending confirmation emails.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that gets directly to the point. No wasted words, and it is front-loaded with the action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with 4 documented parameters and an output schema exists, which covers return values. However, the description alone omits edge-case behavior like duplicate emails, but this is acceptable given schema thoroughness; still, it's minimal.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All four parameters are fully described in the schema (email, last_name, first_name, unsubscribed), so the description adds no additional semantic value. The schema coverage is 100%, so a baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('Create') and resource ('contact'), distinguishing it from siblings like update_contact and delete_contact. It is concise and unambiguous, though it doesn't provide additional scope details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives, such as when to use update_contact for existing contacts. There are no prerequisites or contextual cues.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove a contact.
| Name | Required | Description | Default |
|---|---|---|---|
| contact_id | Yes | The contact ID to delete |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Remove a contact' without mentioning irreversibility, side effects, authentication, or return behavior, leaving critical behavioral traits undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief but also under-specified, essentially restating the tool name. It does not include necessary behavioral context, making it more of a placeholder than a concise valuable description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even for a simple delete tool, the description is incomplete: it doesn't explain what happens upon deletion (e.g., success response, errors), any permanence implications, or permissions required. The presence of an output schema is not leveraged to clarify return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the single parameter contact_id with a clear description, so the description adds no additional parameter semantics. Baseline 3 applies due to 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (Remove) and the resource (contact), which differentiates it from create/get/update siblings. It is specific but lacks any additional scope or detail that would elevate it to a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like update_contact, nor any prerequisites or conditions. The description offers no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a single contact by ID.
| Name | Required | Description | Default |
|---|---|---|---|
| contact_id | Yes | The contact ID to retrieve |
| Name | Required | Description |
|---|---|---|
| id | Yes | Contact ID |
| Yes | Email address | |
| last_name | No | Last name |
| created_at | No | Created timestamp |
| first_name | No | First name |
| unsubscribed | No | Global unsubscribe status |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. The verb 'Get' implies a read-only operation, but it does not explicitly state that no data is modified, nor does it mention any permissions, error conditions, or rate limits. The minimal wording is adequate but lacks richer context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word is informative and necessary, achieving maximum conciseness without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one parameter, read-only, output schema exists), so the brief description is largely sufficient. It could be slightly more complete by explicitly stating that it returns the full contact record or that contact_id is unique, but these are either implied by the resource type or covered by the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the parameter contact_id is fully documented in the schema. The description adds no additional meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and the resource ('single contact by ID'), which distinguishes it from sibling tools like list_contacts (retrieves multiple contacts) and get_email (retrieves an email). It is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as list_contacts or get_email. There are no explicit use cases, prerequisites, or exclusions, so the agent must infer usage solely from the name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get email details including delivery status.
| Name | Required | Description | Default |
|---|---|---|---|
| email_id | Yes | The email ID to retrieve |
| Name | Required | Description |
|---|---|---|
| cc | No | CC recipients |
| id | Yes | Email ID |
| to | No | Recipient addresses |
| bcc | No | BCC recipients |
| from | Yes | Sender address |
| html | No | HTML content |
| text | No | Plain text content |
| subject | No | Email subject |
| reply_to | No | Reply-to addresses |
| created_at | No | Created timestamp |
| last_event | No | Last delivery event (e.g. delivered, bounced) |
| scheduled_at | No | Scheduled send time |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only mentions 'including delivery status' as extra info, but it doesn't state expected side effects (though implied read-only), error behavior, or any access requirements. The description is largely minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that immediately tells the user what the tool does. No filler or repetition, every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter and an output schema present, so the short description is largely sufficient. It doesn't explain return values (handled by output schema) but provides core purpose and a key detail. Given the low complexity, the description covers the essential context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the email_id parameter (100% coverage), so the description doesn't need to add much. It adds no extra semantic detail about the parameter itself, hence the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action (get) and resource (email details), and adds a specific feature (delivery status). However, it doesn't distinguish from sibling tools like list_emails, so it's clear but not fully differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives such as list_emails. It doesn't mention prerequisites, exclusions, or alternate tool names, leaving the usage context entirely inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List contacts with optional segment filtering.
| Name | Required | Description | Default |
|---|---|---|---|
| after | No | Cursor for forward pagination | |
| limit | No | Max results (1-100, default 20) | |
| before | No | Cursor for backward pagination | |
| segment_id | No | Filter by segment ID |
| Name | Required | Description |
|---|---|---|
| data | No | |
| object | No | |
| has_more | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It says 'List', implying a read-only operation, but does not mention pagination, sorting, or what fields are returned. It provides minimal context beyond the obvious.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It is highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, comprehensive parameter schema, and presence of an output schema, the description is adequate. It could briefly mention pagination or the default behavior of returning all contacts, but the parameters already convey these details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes all four parameters (100% coverage). The description adds only 'optional segment filtering', which mirrors the schema's segment_id and does not enrich parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists contacts, with an optional segment filter. It distinguishes from siblings like get_contact (single contact) and list_emails (different resource type).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The purpose is clear enough to infer when to use: for listing contacts, optionally filtered by segment. However, it does not explicitly state when to avoid this tool or prefer siblings like get_contact for a specific contact.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List sent emails with pagination.
| Name | Required | Description | Default |
|---|---|---|---|
| after | No | Cursor for forward pagination | |
| limit | No | Max results (1-100, default 20) | |
| before | No | Cursor for backward pagination |
| Name | Required | Description |
|---|---|---|
| data | No | |
| object | No | |
| has_more | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full transparency burden. It only mentions pagination, not other behavioral traits such as read-only nature, sorting, or response format, which are left entirely to the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the action and resource. It contains no filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list operation with full schema coverage and an output schema, the description is minimally viable. However, it lacks usage guidelines and deeper behavioral context, preventing a higher score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for after, limit, and before. The description's mention of pagination adds a minor hint but does not go beyond the schema, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists sent emails with pagination, using a specific verb and resource. It is easily distinguished from sibling tools like get_email (single email) or send_email (create/send).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of using get_email for single email retrieval or list_contacts for contacts, leaving the choice implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all contact segments.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| data | No | |
| object | No | |
| has_more | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility for behavioral disclosure. It clearly indicates the operation is a read-only list of all segments, but provides no additional context about response format or potential limitations. The output schema exists, so returning details are covered, but the description itself is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no filler or redundancy. It immediately conveys the action and the subject.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list operation with no parameters and an existing output schema, this description is fully sufficient. It states the complete scope ('all contact segments') and leaves nothing ambiguous for the user.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema provides complete coverage without needing description-level elaboration. The baseline for 0 parameters is 4, and the description adds no conflicting or extra information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List all contact segments' uses a specific verb ('list') and clarifies the exact resource ('contact segments'), making its purpose unmistakable. It distinguishes itself from sibling tools that target contacts or emails, as segments are a separate entity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when a complete list of segments is needed, and there are no competing sibling tools for segments. However, it does not explicitly state exclusions or alternative scenarios, which would push it to a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send an email via Resend.
| Name | Required | Description | Default |
|---|---|---|---|
| cc | No | CC recipients | |
| to | Yes | Recipient email addresses (max 50) | |
| bcc | No | BCC recipients | |
| html | No | HTML body content | |
| text | No | Plain text body (auto-generated from HTML if omitted) | |
| subject | Yes | Email subject line | |
| reply_to | No | Reply-to addresses | |
| from_address | Yes | Sender email (e.g. "Name <email@domain.com>") | |
| scheduled_at | No | Schedule delivery (ISO 8601 or natural language) |
| Name | Required | Description |
|---|---|---|
| id | Yes | Email ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It only says 'Send an email via Resend' without revealing that this is an external side-effecting operation, potential delivery failures, authorization requirements, or that sending cannot be undone. This is a meaningful omission for a tool that triggers an external action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately states the action and target. There is no redundant or irrelevant content, and it is front-loaded. While it lacks depth, brevity is a strength here.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 9 parameters, 3 required, and an important external side effect, the description should provide context about the operation's scope, limitations, or typical use cases. None is given. The output schema exists, so return values are covered, but the description leaves the tool's role and edge cases unexplained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the schema already provides clear descriptions for all parameters. The tool description adds no extra meaning beyond the schema, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('send') and resource ('email via Resend'), clearly distinguishing this tool from siblings like create_contact, list_emails, and get_email. The action is unambiguous and cannot be confused with other tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention when to send an email, prerequisites, or exclusions (e.g., 'Use for transactional emails only'). The user must infer usage solely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update an existing contact.
| Name | Required | Description | Default |
|---|---|---|---|
| last_name | No | New last name | |
| contact_id | Yes | The contact ID to update | |
| first_name | No | New first name | |
| unsubscribed | No | New subscription status |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Update an existing contact.' It does not disclose mutation semantics, whether unspecified fields are preserved, how null values are handled, error behavior for nonexistent contact_id, or any permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single four-word sentence with zero waste and front-loaded intent. However, its extreme brevity sacrifices informational value, making it concise but not optimally helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having a complete input schema and an output schema, the description omits critical behavioral context for a mutation tool: partial-update semantics, null-field interpretation, effects of updating 'unsubscribed', and failure behavior. The lack of annotations makes this a significant gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all four parameters (contact_id, first_name, last_name, unsubscribed). The description adds no parameter-level meaning, landing at the baseline 3 for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update an existing contact.' states a specific verb (update) and resource (contact), clearly conveying the action. The qualifier 'existing' subtly distinguishes it from the sibling create_contact, though it does not explicitly differentiate from the other contact-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus create_contact, delete_contact, or get_contact. There are no exclusions, prerequisites, or alternative tool mentions, leaving the agent to infer usage solely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.3.0create_contactdelete_contactget_contactget_emaillist_contactslist_emailslist_segmentssend_emailupdate_contactEach tool targets a distinct resource and action: contacts have CRUD operations, emails have send/get/list, and segments have list. No ambiguity exists between tools.
All tools use a consistent verb_noun pattern in snake_case (e.g., create_contact, send_email, list_contacts), making actions clear and predictable.
9 tools is ideal for the server's purpose, covering email sending and contact management without unnecessary bloat or missing core functionality.
Contacts have full CRUD, emails support send and retrieval, and segments are listable. The only gap is lack of segment management (create/update/delete), which is a minor workaround for most use cases.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Email for AI agents: send, read replies as threads, run campaigns, with per-key limits.
Email for AI agents — send, receive as a webhook, manage domains, templates, routing.
AI email inbox and sending tools with attachments, search, live events, and webhooks.
Stateful email for AI agents — read inboxes, reply in-thread, draft with approval.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/JoeCardoso13/mcp-resend'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
