Fax API for developers & AI agents

The simplest Fax API available.

FaxDrop's REST fax API lets you send faxes programmatically with a single POST request. Destinations in the 50 US states and Canada are supported for launch. Other destination countries are not currently available through the send endpoints. Healthcare workflow support. Pay per fax, no monthly minimum. API keys available now from your account dashboard.

Quickstart Guide API Reference View Pricing Developer Changelog

What is the FaxDrop fax API?

The FaxDrop fax API is a REST API for sending faxes from code. There is no fax machine, no fax line, and no legacy telephony stack to manage. You POST a document and a recipient number to one endpoint, and FaxDrop transmits the fax over the carrier network. When you need delivery status, you GET one endpoint with the fax ID.

Two HTTP calls are the whole integration. That is the point. Most fax APIs were built for enterprise telecom buyers, so they ship with SDKs, webhook configuration, number provisioning, and a sales call before you can send a page. FaxDrop is built for developers who just need a fax to go out from an app, a script, a cron job, or an AI agent.

It is a real REST API, not a contact form with a slow backend. Authentication is a single X-API-Key header. Pricing is per fax, with no monthly minimum and no per-seat licensing. You can send your first fax in under five minutes from the account dashboard.

How it works: send and poll

Send a fax. Make a POST /api/send-fax request with a multipart form. Required fields are the document (file, as PDF, JPEG, or PNG), the recipient fax number in E.164 format, a sender name, and a sender email for confirmation. You get back a faxId immediately.

Check status. Poll GET /api/v1/fax/{faxId} with the same API key. The response tells you whether the fax is queued, sending, completed, failed, or partial, plus the page count and a completion timestamp once it finishes. Most US faxes deliver in under 90 seconds.

That is the full lifecycle. No webhook setup is required to get a working integration; you poll status on your own schedule. Destinations in the 50 US states and Canada are supported today.

Quickstart

Three steps. Under five minutes. No SDK required.

Create an account

Sign in with Google at faxdrop.com. You get 2 free faxes per month on the free plan, up to 5 pages including cover. No credit card required to get started.

Generate an API key

Go to your account dashboard and open the API Keys section. Click Generate New Key. Copy the key immediately. You can create up to 3 active keys per account.

Store your key securely. It is shown once at creation. If you lose it, revoke it and generate a new one. Never commit API keys to source control.

Send a fax

POST a multipart form with the recipient number and your document. We accept PDF, JPEG, and PNG files up to 4 MB. Export Word documents as PDF first. Pass your key as an X-API-Key request header.

curl -X POST https://www.faxdrop.com/api/send-fax \
  -H "X-API-Key: fd_live_your_api_key_here" \
  -F "recipientNumber=+12125551234" \
  -F "senderName=Your App" \
  -F "senderEmail=you@example.com" \
  -F "sendEmail=true" \
  -F "includeCover=true" \
  -F "recipientName=Dr. Jane Smith" \
  -F "subject=Patient records request" \
  -F "senderCompany=Acme Medical Group" \
  -F "senderPhone=+13155550123" \
  -F "file=@document.pdf"

Use with an AI agent

New

Copy a ready-made prompt that teaches any AI assistant (Claude, ChatGPT, etc.) how to send faxes using your FaxDrop API key.

API Reference

Base URL: https://www.faxdrop.com

Authentication

All API requests require an API key passed via the X-API-Key header. API keys start with fd_live_ followed by 32 hex characters.

You can also use FaxDrop programmatically through a web session (cookie-based auth), but API keys are required for server-to-server integrations and AI agent workflows. Requests authenticated with an API key are tracked separately in your usage dashboard.

X-API-Key: fd_live_a1b2c3d4e5f6...

POST/api/send-fax

Send a fax to numbers in the 50 US states and Canada.

Request Headers

X-API-KeyRequired. Your API key. Generate one at faxdrop.com/account.

Content-TypeSet to multipart/form-data (most HTTP clients set this automatically when you pass form data).

Form Fields

Field	Type	Required	Description
`file`	File	Yes	Document to fax. PDF, JPEG, or PNG. Max 4 MB.
`recipientNumber`	String	Yes	Recipient fax number in E.164 format. Destinations in the 50 US states and Canada are supported for launch. Other destination countries are not currently available through the send endpoints. Example: `+12125551234`
`senderName`	String	Yes	Sender name. Appears on the fax cover page. Can be your app name or a person's name.
`senderEmail`	String	Yes	Email address for delivery confirmation. Does not need to match your account email.
`sendEmail`	String	No	API-key sends only. Defaults to `"true"`. Set to `"false"` to suppress delivered-fax confirmation emails for batch workflows. Failed-fax emails, status pages, refunds, and operator alerts still run.
`includeCover`	String	No	Set to `"true"` to include a cover page. Defaults to no cover for paid users. Free-tier faxes always include a branded cover page.
`coverNote`	String	No	Message printed on the cover page. Only used when `includeCover` is `true`. Max 500 characters.
`recipientName`	String	No	Recipient's display name for the cover page. Example: `Dr. Jane Smith`
`subject`	String	No	RE: subject line printed on the cover page. Max 200 characters.
`senderCompany`	String	No	Sender's company or organization name. Displayed alongside `senderName` on the cover page. Max 100 characters.
`senderPhone`	String	No	Sender's phone number. Printed on the cover page for recipient callbacks. Example: `+13155550123`

Success Response 200 OK

{
  "success": true,
  "faxId": "fax_abc123",
  "deliveryEmail": "enabled"
}

Field	Type	Description
`success`	Boolean	Always `true` on a 200 response.
`faxId`	String	Unique identifier for this fax. Use this to track delivery status.
`deliveryEmail`	String	Public echo of the delivered-fax email preference. Returns `enabled` or `suppressed`. Non-API sends return `enabled`.

GET/api/v1/fax/{faxId}

Check the delivery status of a fax. Poll this endpoint until the status is completed, failed, or partial.

Path Parameters

faxIdRequired. The fax ID returned from POST /api/send-fax.

Request Headers

X-API-KeyRequired. Your API key. You can only check faxes sent from your own account.

Status Values

Status	Meaning
`queued`	Fax accepted and waiting to be transmitted.
`sending`	Fax is currently being transmitted to the recipient.
`completed`	Fax was successfully delivered to the receiving fax machine. `pages` and `completedAt` will be populated.
`failed`	Fax delivery failed. Check the `error` field for details.
`partial`	Some pages were delivered but the transmission was interrupted.
`unknown`	FaxDrop could not currently determine the upstream status. Retry status polling with backoff.

Success Response 200 OK

{
  "id": "fax_abc123",
  "status": "completed",
  "recipientNumber": "+12125551234",
  "pages": 3,
  "completedAt": "2026-03-03T12:34:56.000Z",
}

When a fax fails, the response includes carrier failure fields when available:

{
  "id": "fax_abc123",
  "status": "failed",
  "recipientNumber": "+12125551234",
  "pages": null,
  "completedAt": null,
  "error": "Line busy. No answer after 3 attempts.",
  "errorCode": 1001,
  "errorType": "CALL_ERROR"
}

Field	Type	Description
`id`	String	The fax ID you queried.
`status`	String	Current delivery status. One of: `queued`, `sending`, `completed`, `failed`, `partial`, `unknown`. Treat legacy `delivered` as completed if an older client cached that value.
`recipientNumber`	String \| null	The fax number the document was sent to.
`pages`	Number \| null	Number of pages transmitted. Populated after delivery completes.
`completedAt`	String \| null	ISO 8601 timestamp when the fax finished (completed, failed, or partial). Null while in progress.
`error`	String \| null	Error description. Only present when status is `failed` or `partial`.
`errorCode`	Number \| null	Carrier error code when Sinch provides one. Only present when status is `failed` or `partial`.
`errorType`	String \| null	Machine-readable carrier error type when available, such as `DOCUMENT_CONVERSION_ERROR`.

Polling Tips

Most faxes deliver in under 90 seconds. A reasonable polling strategy:

Poll every 5 seconds for the first 2 minutes
Then every 30 seconds for up to 10 minutes
Stop polling once status is completed, failed, or partial

Status checks use their own read-only limit bucket: 60/min, 500/hr, 2000/day. Active faxes refresh from Sinch at most once every 10 seconds per fax ID.

Example Requests

cURL

curl https://www.faxdrop.com/api/v1/fax/fax_abc123 \
  -H "X-API-Key: fd_live_your_api_key_here"

Python

import requests

response = requests.get(
    "https://www.faxdrop.com/api/v1/fax/fax_abc123",
    headers={"X-API-Key": "fd_live_your_api_key_here"},
)

data = response.json()
print(data["status"])  # "completed"

Node.js

const res = await fetch(
  "https://www.faxdrop.com/api/v1/fax/fax_abc123",
  { headers: { "X-API-Key": "fd_live_your_api_key_here" } },
);

const data = await res.json();
console.log(data.status); // "completed"

Error Reference

All errors follow the same JSON schema.

Error responses include an error message, a machine-readable error_type, and when applicable a hint with a suggested fix and a retry_after value in seconds.

// 401 - Invalid or missing API key
{
  "error": "API key not found or revoked.",
  "error_type": "unauthorized",
  "hint": "Check your key at https://faxdrop.com/account or generate a new one."
}

// 402 - No credits remaining
{
  "error": "Insufficient credits. Please top up your account.",
  "error_type": "payment_required",
  "hint": "Add credits at https://faxdrop.com/pricing.",
  "retry_after": 3600
}

// 429 - Rate limit hit
{
  "error": "Rate limit exceeded. You are allowed 30 requests per hour.",
  "error_type": "rate_limited",
  "retry_after": 42
}

// 400 - Bad request
{
  "error": "Unable to process your document.",
  "error_type": "bad_request",
  "hint": "Supported formats: PDF, JPG, PNG. Export Word documents as PDF first. Max 4 MB."
}

HTTP Status	error_type	When it happens
`400`	`bad_request`	Missing required fields, invalid fax number format, unsupported file type, file too large
`401`	`unauthorized`	Missing API key, key not found, key revoked, wrong key format
`402`	`payment_required`	No credits remaining, free tier exhausted. Check `retry_after` for when you can try again after topping up.
`429`	`rate_limited`	Per-key rate limit exceeded. See Rate Limits below. `retry_after` tells you exactly how many seconds to wait.
`500`	`internal_error`	Unexpected server error. These are rare. Retry after a few seconds. Contact support if they persist.

Rate Limits

Send and status polling use separate fixed-window buckets per API key.

Policy	Endpoint	Minute	Hour	Day	Response header
`send_fax`	`POST /api/send-fax`	10	30	500	`X-RateLimit-Limit` / `X-RateLimit-Remaining`
`status_poll`	`GET /api/v1/fax/{faxId}`	60	500	2000	`X-RateLimit-Limit-Hour` / `X-RateLimit-Remaining-Hour`
Non-API-key web sends	`POST /api/send-fax` without a valid API key	-	5 per IP	-	This web abuse guard applies to anonymous and signed-in web sends, but not valid API-key sends.

Every successful API-key response includes X-RateLimit-* headers so you can track your quota in real time. X-RateLimit-Policy names the active policy. When you hit a limit, the response also includes a Retry-After header and a retry_after field in the JSON body.

Rejected requests (429 responses) do not count against your limit. Only successful requests consume quota.

X-RateLimit-Limit: 10
X-RateLimit-Remaining: 7
X-RateLimit-Reset: 1740924120
X-RateLimit-Limit-Hour: 30
X-RateLimit-Remaining-Hour: 29
X-RateLimit-Limit-Day: 500
X-RateLimit-Remaining-Day: 499
X-RateLimit-Policy: send_fax

Usage Tracking

All faxes sent via API key are logged separately from web UI faxes. Your account dashboard shows monthly API usage counts and recent activity per key. Usage data is retained for 400 days.

Credits are shared across API and web UI usage. Each fax costs the same regardless of how it was initiated. Check your pricing plan for per-fax rates.

The API uses the same credit model as the rest of FaxDrop. One credit covers one outbound fax of up to 10 pages; longer documents consume one credit per 10-page block. Pay per fax at $1.99, or buy a credit pack or subscription for a lower per-fax rate. Web sends and API sends draw from the same balance.

Using the fax API with AI agents

FaxDrop is built so an AI agent can send a fax the same way a person does: one authenticated REST call, no browser. Point your agent at POST /api/send-fax with an X-API-Key header and it can fax PDFs, then confirm delivery with GET /api/v1/fax/{faxId}.

If you are working in the Model Context Protocol ecosystem, a community-maintained MCP server, klodr/faxdrop-mcp, exposes the FaxDrop send and status endpoints as MCP tools, with a path jail, dry-run mode, and an audit log. It is a third-party community integration that FaxDrop endorses, not a FaxDrop-operated server. FaxDrop accepts PDF, JPG, and PNG up to 4 MB, so the supported file types and size follow the API no matter which client you use.

FaxDrop Fax API vs. the alternatives

Most fax APIs are built for enterprises with monthly minimums and complex onboarding. FaxDrop is built for developers who need fax without the overhead. Migrating from Twilio? See our Twilio migration guide.

Feature	FaxDrop	Fax.Plus	Telnyx	RingCentral
Pricing model	Pay per fax ($1.99)	Subscription + overage	Per page ($0.007+)	Plan-bundled (RingEX)
Monthly minimum	None	Yes	No	Yes
Suitable for healthcare workflows	Yes (Sinch BAA)	Enterprise plan only	Yes (BAA required)	Enterprise plan
Time to first fax	Under 5 minutes	15-30 minutes	30+ minutes	Plan signup
Free tier	2 faxes/month	10 pages (one-time)	None	None
Document retention	Not retained after send	Stored on servers	Stored on servers	Stored on servers
API complexity	2 endpoints	Full REST + webhooks	Full REST + webhooks	Complex SDK required

What developers are building

FaxDrop handles the fax infrastructure so you can focus on your product.

Healthcare platforms

Send prescriptions, referrals, and medical records to providers who still require fax. Built for healthcare workflows with uploaded files not retained by FaxDrop app storage after send.

Legal document systems

Court filings, signed agreements, and discovery documents sent to fax-only recipients. Delivery confirmations for your audit trail.

Government form automation

IRS submissions, state filings, permit applications. Many government agencies still require fax. Automate the last mile.

AI agents and workflows

Give your AI agent the ability to fax. Your agent owns the workflow logic; FaxDrop handles the transmission. The same X-API-Key REST call works from an agent, a tool call, or a function. A community-built MCP server (klodr/faxdrop-mcp) already wraps the send and status endpoints as MCP tools,.

Why developers choose FaxDrop

Healthcare fax posture

Sinch BAA-backed transmission. Encrypted upload transport. Uploaded files not retained by FaxDrop app storage after send. Built for healthcare and legal workflows.

Under 90 Seconds

Most US faxes deliver in under 90 seconds. Poll the status endpoint to track delivery.

Two Endpoints

POST /api/send-fax to send. GET /api/v1/fax/{id} to poll status. Multipart form. PDF, JPEG, or PNG. That is the entire integration.

Pay Per Fax

No monthly minimums. No seat licensing. $1.99 per fax or subscribe for volume discounts. Credits never expire.

Agent-Ready

Built for the MCP era. Your AI agent can send faxes the same way a human does. No browser required.

Twilio Fax Is Gone

Twilio deprecated their fax API. FaxDrop is the modern replacement: simpler, cheaper, built for healthcare workflows.

Fax API FAQ

What is a fax API?

A fax API lets you send and track faxes from code instead of a fax machine. You make an HTTP request with your document and the recipient number, and the provider transmits the fax over the carrier network. FaxDrop's fax API is two REST endpoints: one to send, one to check status.

What is the best fax API for developers?

The best fax API depends on what you are optimizing for. If you want the simplest path to a working integration, FaxDrop is two endpoints, X-API-Key auth, pay per fax, and no monthly minimum. If you need heavy enterprise telecom features, a larger telecom platform may fit better. For most apps, scripts, and AI agents that just need faxes to go out, fewer moving parts wins.

Is there a simple fax API?

Yes. FaxDrop is a deliberately simple fax API. POST /api/send-fax to send, GET /api/v1/fax/{faxId} to poll status, one header for auth, multipart form for the file. No SDK is required and there is nothing to provision before your first send.

How do I send a fax with an API?

Generate an API key in your account dashboard, then POST a multipart form to /api/send-fax with your X-API-Key header, the recipient number in E.164 format, a sender name and email, and your PDF, JPEG, or PNG file. You get back a faxId to track delivery.

Do I need a fax number to use the fax API?

No. You do not provision or rent a fax number to send with FaxDrop. You send to a recipient's fax number; FaxDrop handles the outbound transmission. Inbound fax numbers are a separate capability and are not part of the send API.

Can an AI agent send a fax?

Yes. The fax API is a single authenticated REST call, so any AI agent or tool-calling workflow can send a fax and poll its status. A community MCP server (klodr/faxdrop-mcp) wraps the endpoints as MCP tools,.

Is the FaxDrop fax API a Twilio Fax alternative?

Yes. Twilio deprecated its fax API, so teams that built on it need a replacement. FaxDrop covers the same core need, send a fax from code and confirm delivery, with a simpler two-endpoint surface. See our Twilio migration guide.

Ready to integrate?

Create a Free Account View Pricing

Questions? Email us at support@faxdrop.com or visit /support.

Security & Compliance

Healthcare faxing

Carrier BAA signed | Uploaded files not retained by FaxDrop

PCI DSS Level 1

Payments secured by Stripe | No card data touches our servers

256-bit SSL

End-to-end TLS 1.2+ encryption in transit

App Storage

Uploaded files are cleared from FaxDrop after send