Reply to Email

This endpoint allows you to reply to emails received through Inbound, maintaining proper email threading with In-Reply-To and References headers.

Authentication

This endpoint requires authentication via:

API key auth: Bearer token in Authorization header

Path Parameters

string

required

The unique identifier of the email or thread you want to reply to.Can be either:

An email ID (e.g., inbnd_abc123def456ghi) - Replies to that specific email
A thread ID (e.g., thread_xyz789) - Replies to the latest message in the thread

When providing a thread ID, the system automatically replies to the most recent email in that thread, ensuring proper conversation continuity.

Request Body

from

string

required

The sender email address.Must be in the format "Name <email@domain.com>" or "email@domain.com".The domain must be verified in your account.

You cannot use agent@inbnd.dev for replies. This email is only available for sending new emails, not for replying to received emails.

from_name

string

Optional sender name for display. If provided, this will be used as the display name for the sender address.

string | string[]

The recipient email address(es). If not provided, the reply will be sent to the original sender. Can be a single email string or an array of email strings.

subject

string

The email subject. If not provided, “Re: ” will be prepended to the original email’s subject.

string | string[]

Carbon copy recipient(s). Can be a single email string or an array of email strings.

bcc

string | string[]

Blind carbon copy recipient(s). Can be a single email string or an array of email strings.

reply_to

string | string[]

Reply-to address(es). Can be a single email string or an array of email strings.

The reply_to method will be deprecated in a future version.

replyTo

string | string[]

Reply-to address(es). Can be a single email string or an array of email strings.

text

string

The plain text version of the email body. Either text or html must be provided.If you only provide html the text will be generated automatically from the HTML.

html

string

The HTML version of the email body.

headers

object

Custom email headers as key-value pairs. These will be added to the email in addition to the standard headers.

{
  "X-Priority": "1",                    // High priority
  "X-Support-Ticket": "TICKET-12345",  // Ticket tracking
  "X-Department": "Customer-Support",   // Department routing
  "Reply-To": "noreply@yourdomain.com", // Override reply-to
  "X-Auto-Reply": "true"                // Mark as automated
}

Headers are merged with threading headers (In-Reply-To, References) and standard email headers (Message-ID, Date, etc.). Custom headers take precedence over defaults but cannot override required threading headers.

attachments

array

Array of file attachments to include with the email.

Show Attachment object properties

content

string

Base64 encoded file content. Required if path is not provided.

path

string

URL to fetch the attachment from. Required if content is not provided. Only HTTP and HTTPS URLs are supported.

filename

string

required

Name of the file

content_type

string

MIME type of the file (e.g., “application/pdf”, “image/png”). Also accepts contentType (camelCase) for Resend compatibility.

content_id

string

Content ID for embedding images in HTML email using cid: references (e.g., <img src="cid:logo">). Must be unique across all attachments.

include_original

boolean

default:"true"

Whether to include the original message as a quoted reply. When true, the original message will be appended to your reply with appropriate formatting. Also accepts includeOriginal (camelCase) for Resend compatibility.

replyAll

boolean

default:"false"

Whether to reply to all recipients (Reply All behavior).When true:

Includes the original sender in the to field
Includes all original CC recipients (excluding yourself)
Does NOT include BCC recipients (as per email standards)

When false (default):

Only replies to the original sender

The current user’s email address is automatically excluded from the recipient list to prevent self-replies.

Headers

Authorization

string

required

Bearer token for API authentication.

Idempotency-Key

string

Add an idempotency key to prevent duplicate replies. * Should be unique per API request * Idempotency keys expire after 24 hours * Have a maximum length of 256 characters

API-Version

string

Specify a historical API version to maintain backward compatibility.Available versions:

reply-10-01-25 - Legacy reply endpoint from January 1, 2025

Omit this header to use the current API version with the latest features (recommended).

Response

string

required

Unique identifier for the sent reply email in Inbound’s system

messageId

string

required

The Inbound message ID used for email threading (appears in Message-ID header)

awsMessageId

string

AWS SES Message ID for tracking the email through AWS infrastructure. Only present when the email is successfully sent through AWS SES.

repliedToEmailId

string

required

The actual email ID that was replied to. This is always an email ID, even if you provided a thread ID in the request.

repliedToThreadId

string

The thread ID associated with the email, if the reply is part of a conversation thread.

isThreadReply

boolean

required

Indicates whether the reply was made to a thread ID (true) or directly to an email ID (false).

When true, the system automatically resolved the thread ID to the latest email in that thread.

Email Threading

This endpoint automatically handles email threading by:

Setting the In-Reply-To header with the Message-ID of the original email
Building the References header to maintain the full conversation thread
Formatting the subject with “Re: ” prefix if not already present
Quoting the original message (when include_original is true) with proper attribution

Email clients like Gmail, Outlook, and Apple Mail will recognize these threading headers and group the emails into a conversation.

API Versioning

The reply endpoint supports API versioning to maintain backward compatibility while introducing new features.

Current Version (Recommended)

The current version includes:

Thread ID support - Reply to threads or specific emails
Reply All functionality - Include all original recipients
Enhanced response data - Detailed information about what was replied to
Automatic thread resolution - Seamlessly works with both email and thread IDs

To use the current version, simply omit the API-Version header.

Historical Versions

Access previous API implementations by including the API-Version header:

curl -X POST https://inbound.new/api/v2/emails/inbnd_abc123def456ghi/reply \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "API-Version: reply-10-01-25" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "support@yourdomain.com",
    "text": "Your reply message"
  }'

Historical versions are maintained for backward compatibility only. New integrations should use the current version to access the latest features and improvements.

Version Differences

Feature	reply-10-01-25	Current
Thread ID support	❌ Email IDs only	✅ Email or Thread IDs
Reply All	❌ Not available	✅ Available
Response includes thread info	❌ Basic response	✅ Full thread details
Simplified mode	✅ Available	✅ Available
Attachments	✅ Supported	✅ Supported
Custom headers	✅ Supported	✅ Supported

Examples

Basic Reply

Reply to an email with minimal configuration:

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound('YOUR_API_KEY');

const { data, error } = await inbound.reply('inbnd_abc123def456ghi', {
from: 'support@yourdomain.com',
text: 'Thank you for your email. We have received your request and will respond shortly.'
});

if (error) {
console.error('Error:', error);
} else {
console.log('Reply sent:', data.id);
}

{
  "id": "sent_xyz789",
  "messageId": "xyz789@yourdomain.com",
  "awsMessageId": "0100018e1234abcd-12345678-1234-1234-1234-123456789012-000000",
  "repliedToEmailId": "inbnd_abc123def456ghi",
  "repliedToThreadId": "thread_def456",
  "isThreadReply": false
}

Advanced Reply with Custom Recipients

Reply with custom recipients, subject, HTML content, and tags:

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound('YOUR_API_KEY');

const { data, error } = await inbound.reply('inbnd_abc123def456ghi', {
from: 'john@yourdomain.com',
to: ['customer@example.com'],
cc: ['manager@yourdomain.com'],
subject: 'Re: Support Request #12345',
text: 'Dear Customer,\n\nWe have resolved your issue...',
html: '<p>Dear Customer,</p><p>We have resolved your issue...</p>',
headers: {
'X-Support-Ticket': '12345'
},
includeOriginal: true,
tags: [
{ name: 'category', value: 'support' },
{ name: 'priority', value: 'high' }
]
});

Reply All to Include CC Recipients

Use Reply All to include all original recipients in your response:

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound('YOUR_API_KEY');

const { data, error } = await inbound.reply('inbnd_abc123def456ghi', {
  from: 'support@yourdomain.com',
  text: 'This response is going to everyone on the original email.',
  replyAll: true  // Include original sender + CC recipients
});

if (error) {
  console.error('Error:', error);
} else {
  console.log('Reply All sent:', data.id);
  console.log('Replied to email:', data.repliedToEmailId);
}

Reply All automatically:

Includes the original sender
Includes all CC recipients from the original email
Excludes your own email address to prevent self-replies
Does NOT include BCC recipients (per email standards)

Reply to a Thread

Reply to an entire conversation thread by using the thread ID:

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound('YOUR_API_KEY');

// Using a thread ID instead of an email ID
const { data, error } = await inbound.reply('thread_xyz789', {
  from: 'support@yourdomain.com',
  text: 'This reply continues the conversation thread.'
});

if (error) {
  console.error('Error:', error);
} else {
  console.log('Reply sent to thread:', data.repliedToThreadId);
  console.log('Actual email replied to:', data.repliedToEmailId);
  console.log('Was thread reply:', data.isThreadReply);  // true
}

{
  "id": "sent_xyz789",
  "messageId": "xyz789@yourdomain.com",
  "awsMessageId": "0100018e1234abcd-12345678-1234-1234-1234-123456789012-000000",
  "repliedToEmailId": "inbnd_latest789xyz012",
  "repliedToThreadId": "thread_xyz789",
  "isThreadReply": true
}

When you provide a thread ID, the system automatically finds the most recent email in that thread and replies to it, ensuring your response appears at the correct position in the conversation.

Reply Without Quoting Original

Send a reply without including the original message:

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound('YOUR_API_KEY');

const { data, error } = await inbound.reply('inbnd_abc123def456ghi', {
from: 'noreply@yourdomain.com',
text: 'This is an automated response.',
includeOriginal: false
});

Reply with Attachments

Include attachments in your reply:

import { Inbound } from '@inboundemail/sdk';
import fs from 'fs';

const inbound = new Inbound('YOUR_API_KEY');

// Read and encode file
const fileContent = fs.readFileSync('invoice.pdf');
const base64Content = fileContent.toString('base64');

const { data, error } = await inbound.reply('inbnd_abc123def456ghi', {
from: 'billing@yourdomain.com',
text: 'Please find the invoice attached.',
attachments: [{
content: base64Content,
filename: 'invoice.pdf',
content_type: 'application/pdf'
}]
});

Error Responses

error

string

Error message describing what went wrong

Common Errors

Status Code	Error Message	Description
400	”Valid email ID or thread ID is required”	The ID parameter is missing or invalid
400	”From address is required”	The `from` field is missing from the request
400	”Either html or text content must be provided”	No email body content was provided
400	”Cannot determine recipient email address”	No `to` field provided and cannot extract from original email
400	”agent@inbnd.dev cannot be used for replies. Please use a verified domain email address.”	Attempted to use agent email for replies
400	”Invalid email format: “	One of the email addresses is malformed
400	”Invalid JSON in request body”	Request body contains malformed JSON
400	”Unknown API version: “	Invalid API version specified in header
401	”Unauthorized”	Invalid or missing API key
403	”You don’t have permission to send from domain: “	The sender domain is not verified in your account
404	”Email or thread not found”	The email/thread ID does not exist or belongs to another user
404	”API version '' not found or unavailable”	The requested API version doesn’t exist
429	”Email sending limit reached. Please upgrade your plan to send more emails.”	You have exceeded your plan’s email sending limit
500	”Email service not configured. Please contact support.”	AWS SES configuration issue
500	”Failed to send reply. Please try again later.”	AWS SES or other service error occurred
500	”Internal server error”	An unexpected error occurred

{
  "error": "You don't have permission to send from domain: unverified.com"
}

Idempotency

This endpoint supports idempotency to prevent duplicate sends. Include an Idempotency-Key header with a unique value:

Basic Idempotency Usage

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound('YOUR_API_KEY');

// Using the organized API with idempotency
const { data, error } = await inbound.email.sent.reply('inbnd_abc123def456ghi', {
from: 'support@yourdomain.com',
text: 'Thanks for your message!'
}, {
idempotencyKey: 'reply-abc123-user456-v1'
});

// Using the simplified reply method with idempotency
const { data, error } = await inbound.reply('inbnd_abc123def456ghi', {
from: 'support@yourdomain.com',
text: 'Your reply message'
}, {
idempotencyKey: 'unique-key-123'
});

Webhook Handler with Idempotency

Perfect for preventing duplicate auto-replies when webhooks are retried:

import { Inbound } from '@inboundemail/sdk';

const inbound = new Inbound(process.env.INBOUND_API_KEY);

// Webhook handler with idempotency protection
export async function POST(request) {
try {
const { email } = await request.json();

    // Create unique key that prevents duplicates even with webhook retries
    const idempotencyKey = `auto-reply-${email.id}-${Math.floor(Date.now() / 60000)}`;

    const { data, error } = await inbound.reply(email.id, {
      from: 'support@yourdomain.com',
      text: 'Thanks for contacting us! We\'ll respond within 24 hours.',
      includeOriginal: false
    }, {
      idempotencyKey
    });

    if (error) {
      console.error('Auto-reply failed:', error);
      return Response.json({ error: 'Failed to send auto-reply' }, { status: 500 });
    }

    return Response.json({ success: true, emailId: data.id });

} catch (error) {
return Response.json({ error: 'Processing failed' }, { status: 500 });
}
}

Idempotency Key Best Practices

Make keys unique and descriptive

Include action type, email ID, and context: reply-{emailId}-{userId}-v1

Use for webhook handlers

Prevent duplicate auto-replies when webhooks are retried due to failures

Include version suffixes

Add -v1, -v2 when you need to update email content for the same operation

Consider time windows

For time-sensitive operations, include timestamp to allow periodic updates

Idempotency Behavior: If you make multiple requests with the same idempotency key, only the first request will send an email. Subsequent requests return the same response without sending a duplicate. Keys expire after 24 hours.

Best Practices

Verify sender domain

Always ensure the from domain is verified in your account before attempting to send replies.

Include both text and HTML

For best compatibility, include both text and html versions of your email content.

Use idempotency keys

When sending replies programmatically, use idempotency keys to prevent accidental duplicate sends.

Handle quoted content carefully

Consider whether including the original message is appropriate for your use case. Automated responses might not need it.

Test threading

Test your replies with various email clients to ensure threading works as expected.

Rate Limits

Reply sending is subject to the same rate limits as the Send Email endpoint. Your plan determines how many emails you can send per month.

Check your current usage and limits in your account dashboard.

1.0 - ✅

Quickstart

Sending & Receiving API

Endpoints API

Addresses API

Domains API

Threads API

Attachments API

Authentication

Path Parameters

Request Body

Headers

Response

Email Threading

API Versioning

Current Version (Recommended)

Historical Versions

Version Differences

Examples

Basic Reply

Advanced Reply with Custom Recipients

Reply All to Include CC Recipients

Reply to a Thread

Reply Without Quoting Original

Reply with Attachments

Error Responses

Common Errors

Idempotency

Basic Idempotency Usage

Webhook Handler with Idempotency

Idempotency Key Best Practices

Best Practices

Rate Limits

Quickstart

Sending & Receiving API

Endpoints API

Addresses API

Domains API

Threads API

Attachments API

​Authentication

​Path Parameters

​Request Body

​Headers

​Response

​Email Threading

​API Versioning

​Current Version (Recommended)

​Historical Versions

​Version Differences

​Examples

​Basic Reply

​Advanced Reply with Custom Recipients

​Reply All to Include CC Recipients

​Reply to a Thread

​Reply Without Quoting Original

​Reply with Attachments

​Error Responses

​Common Errors

​Idempotency

​Basic Idempotency Usage

​Webhook Handler with Idempotency

​Idempotency Key Best Practices

​Best Practices

​Rate Limits

Authentication

Path Parameters

Request Body

Headers

Response

Email Threading

API Versioning

Current Version (Recommended)

Historical Versions

Version Differences

Examples

Basic Reply

Advanced Reply with Custom Recipients

Reply All to Include CC Recipients

Reply to a Thread

Reply Without Quoting Original

Reply with Attachments

Error Responses

Common Errors

Idempotency

Basic Idempotency Usage

Webhook Handler with Idempotency

Idempotency Key Best Practices

Best Practices

Rate Limits