unofax Now Supports x402: Pay Per Fax with USDC

x402 Comes to Fax

unofax now supports x402, the open payment protocol that turns the long-dormant HTTP 402 status code into a working microtransactions standard. You can send a fax through the unofax x402 API for $0.20 USDC per page, with no account, no API keys, and no signup. Pay from any wallet, on the Base network, in a single signed payload.

This post explains what x402 is, why it matters for fax in particular, and how the unofax integration works end to end. It is written for developers building agent tooling, but the same flow works for any human who would rather pay a few cents in USDC than hand over a credit card.

What x402 Actually Is

HTTP 402 Payment Required has been reserved in the HTTP specification since the very first version of HTTP/1.1 was published. For decades it sat unused, with browsers, servers, and proxies all treating it as a placeholder for a future payment standard that never arrived. x402 is the protocol that finally fills that gap.

The mechanics are simple. A client makes a request to a paid endpoint. The server responds with HTTP 402 and a header that describes what payment is required: an amount, an asset (such as USDC), a network (such as Base), and a destination address. The client signs a payment payload with its wallet, retries the request with the signature attached, and the server verifies the on-chain settlement before fulfilling the request. No accounts, no rate-limited keys, no monthly invoices.

The combination of stablecoins like USDC, low-fee L2 networks like Base, and the 402 status code finally makes microtransactions practical at sub-cent latency and sub-cent overhead. You can read the full x402 specification for the protocol details.

Why x402 Matters for Fax

Fax is one of the few APIs where pay-per-call billing actually fits the underlying cost. Every fax has a real, measurable per-page cost on the carrier side, and no one sends a million faxes a day. A traditional fax API forces you to sign up, share a credit card, and minimum-fund a balance just to send a single page. That overhead is bigger than the fax itself.

x402 collapses that overhead to zero. Open the documentation, post a job, sign a payment, and the fax goes out. There is no balance to top up, no plan to choose, no key to rotate. For an occasional fax (a tax form to the IRS, a medical referral, a court filing), this is meaningfully simpler than the existing alternatives. For comparison with the standard browser flow, see our guide to faxing a PDF without a fax machine.

Pricing on the x402 endpoint is a flat $0.20 USDC per page to any of the 45+ supported countries. The cover sheet remains free. There is no markup for international destinations, no surcharge for toll-free numbers, and no minimum spend. Compared to the card-based flow described in our pricing reference, the x402 flow trades a slightly lower per-page rate against the wallet setup overhead.

How the unofax x402 Flow Works

The full integration is documented on the unofax x402 page, but the shape of it is four straightforward HTTP calls. Each call is a normal REST request; only the third one involves a wallet signature.

• Create a fax job. POST to /api/x402 with the destination fax number in E.164 format and a file name. The server returns a job ID, a pre-signed upload URL, and a status endpoint.
• Upload the document. PUT the raw file bytes to the pre-signed URL. unofax accepts the same file formats as the browser flow: PDF, Word, PNG, JPG, HEIC, TIFF, and more.
• Pay and send. POST to the send endpoint without any payment header. The server replies with HTTP 402 and the payment requirement: amount in USDC atomic units, the Base network identifier, and the receiving address. Sign the payment with your wallet per the x402 spec, then resend the same request with the signature in the PAYMENT-SIGNATURE header. The server verifies the on-chain settlement and queues the fax for transmission.
• Check delivery status. Poll the status endpoint every few seconds until the status resolves to sent or failed. Most faxes complete in one to two minutes per page, the same end-to-end timing as the browser flow tracked on the delivery status page.

Cover sheets are supported as a structured object on the create-job request. You can pass a sender name, recipient details, subject, urgency flag, and confidentiality marker, and the cover sheet is rendered as the first page at no extra charge. The same multilingual cover sheet options are available, including locale-specific labels for German, Japanese, Spanish, French, Korean, and several other languages.

Why AI Agents Need This

The most common reaction to a paid API in 2026 is to ask why anyone needs another payment standard. The honest answer is that this one is built for software, not for humans. Card networks were designed around a person typing their number into a form. They assume one cardholder, infrequent transactions, and a chargeback window measured in months. None of that maps to an autonomous agent that needs to make ten purchases in an hour and account for each one independently.

People are far more willing to grant an AI agent a limited cryptocurrency wallet than to share a credit card. A wallet can hold a fixed budget, sign only specific transactions, and be revoked instantly. A credit card cannot. When an agent goes off the rails, you would rather it have $5 in USDC at risk than your full card limit. This trust gap is the structural reason x402 exists, and it is the reason fax is a useful early integration: an agent acting on a user's behalf can fill out a form, prepare a PDF, and send it to a government agency without ever asking the user for a card number.

The unofax x402 endpoint is documented in a way that an agent can self-discover. The OpenAPI-style schema is published on the x402 reference page, the parameters are explicit, and there is no out-of-band onboarding step. An agent that can read documentation and call HTTP can use unofax without a human in the loop.

Comparison: x402 vs Traditional Fax APIs

For developers evaluating where the x402 flow fits, the table below summarises the practical differences against the typical SaaS fax API.

	unofax x402	Traditional Fax API
Signup	None	Email, password, sometimes phone verification
API keys	None	Per-account secret, must be rotated
Minimum spend	One page	Monthly plan or prepaid balance
Per-page cost	$0.20 USDC, flat	Varies by country and plan
Payment method	USDC on Base, signed per request	Credit card on file
Agent-friendly	Yes, schema is self-discoverable	No, requires human onboarding
Settlement time	Seconds, on-chain	Days, via card processor

The traditional flow still makes sense if you are sending thousands of faxes a month and want consolidated billing. For most use cases below that volume, x402 removes more friction than it adds. If you are not sure which side of the line your workload falls on, our comparison post on how online fax services compare walks through the trade-offs in more depth.

Industry Trends: The Rise of AI-Native Services

An AI-native service is one that an autonomous agent can use without modifications: pay-per-use pricing, no account requirement, and self-discoverable APIs accessible through public documentation. This definition is becoming the working standard among developers building agent infrastructure, because each of those properties removes a step where a human would otherwise need to intervene.

Most existing SaaS APIs fail at least one of these tests. They require a signup form, they require a key in a secret manager, or their documentation lives behind a login. None of those are insurmountable barriers for a human, but each one is a hard stop for an agent acting alone. The cumulative effect is that the agent ecosystem in 2026 is bottlenecked on services rebuilding their on-ramps, not on model capability.

Fax is an unlikely but useful example of a service that maps cleanly onto the AI-native definition. The cost per call is real and bounded, the action is concrete and easy to verify (a document arrives at a specific number), and the use cases (government forms, legal filings, medical paperwork) are exactly the kinds of routine tasks people delegate. For more on why fax persists as a transport layer in healthcare, government, and legal workflows, see our deeper post on the topic.

Wallet Setup and Getting Started

To use the unofax x402 endpoint you need a wallet that holds USDC on the Base network and can sign EIP-712 payment payloads. Any wallet that supports Base will work; popular choices include Coinbase Wallet, MetaMask with Base added as a network, and a range of programmatic wallets aimed at agent developers.

Funding the wallet involves bridging USDC to Base or buying it directly on an exchange that supports Base withdrawals. A few dollars is enough to send dozens of pages, since each fax settles individually at $0.20 USDC. There is no need to pre-fund a unofax-side balance; the wallet is the balance.

For the first call, the simplest path is to use one of the example clients in the x402 reference documentation. Each example shows the create, upload, pay, and status calls as plain curl commands plus a short signing helper. Once that round trip works against a test number, the same code works unchanged for any of the country destinations covered on unofax, including the United States, Japan, Germany, and the United Kingdom.

Security, Privacy, and What unofax Does Not See

The x402 flow does not change the underlying document handling. Files uploaded over the pre-signed URL are encrypted in transit and at rest, the same as the browser flow. Documents are deleted automatically after seven days, and you can request earlier deletion through support. The full notes on payment and document security apply equally to x402 jobs.

What x402 specifically removes is the link between you and a billing identity. There is no email address tied to your jobs, no card number on file, and no usage history attached to a customer record. The only identifier the server sees is the wallet address that signed the payment, and a wallet address is as anonymous or as identified as you choose to make it. For users sending sensitive material (a legal filing, a medical record, a tax response), this is a meaningful reduction in the data footprint.

The trade-off is that there is no account-level dashboard. If you need to track usage across many faxes, you do that in your own system using the job IDs returned by the API. For most agent workloads this is the desired behaviour, since the agent is already maintaining its own state.

Practical Notes and Limits

A few constraints are worth knowing before you wire up the integration. None are surprising, but each one matters in production.

• Maximum file size is 100 MB. Larger uploads return HTTP 413 and must be split.
• Maximum page count is 300 per fax. For longer documents, send multiple jobs and reference them in the cover sheet subject lines.
• The send endpoint returns 409 if processing is incomplete. Wait until the status reaches ready_to_send before requesting payment details.
• Payment requirements have an expiry. If you sit on a 402 response too long, request a fresh one. The expiry is included in the status payload.
• Failed transmissions do not refund automatically on x402. Unlike the card flow, on-chain payments are final at settlement. A delivery failure surfaces as failed in the status; contact support with the job ID for resolution.
• Scheduling is supported. Pass an RFC 3339 scheduledTime on job creation, and the fax transmits at that moment after payment is settled. The same logic as the browser-based scheduling applies, including up to seven days in advance.

For high-frequency agent workloads, the practical recommendation is to keep the wallet's USDC balance small and topped up programmatically rather than holding a large balance. This bounds the blast radius if the agent ever misbehaves, and it costs nothing extra because each fax settles independently.

The Bottom Line

x402 turns fax into something an agent can use the same way it uses any other web tool: read the docs, call the API, sign the payment, get the result. unofax now supports it natively at $0.20 USDC per page, with no account, no keys, and the same delivery infrastructure that powers the browser flow. To send your first fax with USDC, open the x402 reference on unofax.com, copy the example, and post your job. To send through the standard browser flow instead, head to unofax.com and drag your PDF onto the upload area.