Fax.live MCP Server

The Fax.live MCP server exposes your fax account to Claude and other AI clients that implement the Model Context Protocol. It provides a set of tools your assistant can call directly, allowing faxes to be sent and tracked in natural language rather than through direct calls to the REST API.

The server runs locally alongside your AI client and authenticates with your own Fax.live API key. It can also manage that key for you: rather than creating, copying, and pasting one by hand, you can have the server provision it and write it into your configuration directly, without the key ever appearing in the conversation.

Installation

1. Install the package

The server is distributed on npm as fax-live-mcp and requires Node.js 20 or later.

npm install -g fax-live-mcp

2. Register the server with your AI client

Add fax-live-mcp as an MCP server using whichever mechanism your client provides for adding one. Leave the API key blank - ask the server to start sign-in instead. If your client is configured by editing a file directly, see Alternative setup.

3. Sign in

Restart your client so the server loads, then ask your assistant to sign in to Fax.live. The server drives the rest of the process and tells the assistant what to prompt you for:

The assistant presents an authorization link and a short confirmation code.
Opening the link asks you to sign in. If you do not yet have a Fax.live account, you will be prompted to create one and then returned to the approval step. Verify that the confirmation code shown in the browser matches the one the assistant provided, and decline the request if it does not.
Tell the assistant once you have approved the request. It then provisions a new API key and writes it into your MCP configuration automatically. Any other MCP servers already defined in that file are preserved.
Restart your client once more, then ask the assistant to verify the Fax.live setup. This invokes check_setup, which confirms that the key is valid and that the service is reachable.

At no point is the API key displayed in the conversation or entered by hand - it is written directly to the configuration file.

The same flow re-runs at any time to replace a revoked or rotated key, or to switch accounts: ask the assistant to sign in to Fax.live again.

Available tools

The following tools are exposed to the connected client. They are not invoked by name - describe the desired outcome and the assistant selects the appropriate tool.

Name	Type	Description
`send_fax`	`Sending`	Sends a fax to a US or Canada number using a previously uploaded file or a publicly hosted PDF.
`get_fax_status`	`Sending`	Returns the delivery status of a previously sent fax.
`get_fax_history`	`Sending`	Lists previously sent faxes, optionally filtered by destination or date range.
`upload_document`	`Documents`	Uploads a local PDF, removing the need to host it publicly before sending.
`check_document`	`Documents`	Validates an uploaded file and reports its page count and estimated cost.
`check_document_by_url`	`Documents`	Performs the same validation against a publicly hosted PDF prior to sending.
`get_balance`	`Billing`	Reports unbilled usage, the monthly base fee, and the next billing date.
`get_billing_history`	`Billing`	Lists account invoices, most recent first.
`check_setup`	`Account`	Confirms that the configured API key is valid and the service is reachable.
`start_login`	`Account`	Initiates authentication and returns an authorization link and confirmation code.
`check_login_status`	`Account`	Completes authentication after approval and writes the key to the configuration file.
`get_service_status`	`Account`	Reports current Fax.live service availability.

Example requests

Representative requests once the server is connected:

"Fax this PDF to +1 415 555 1234."
"Has that fax been delivered?"
"List every fax I sent last week."
"What will it cost to fax this 12-page contract?"
"What is my current balance and next billing date?"

Sending is asynchronous. A fax is queued immediately and transmits over the following minutes, so the assistant polls its status until it reaches a terminal state rather than reporting success on submission. Transmission takes approximately 30-45 seconds per page.

Requirements and limits

Runtime: Node.js 20 or later, and an MCP-compatible client capable of running a local stdio server.
Destinations: United States and Canada only, in E.164 format (for example, +14155551234).
Documents: PDF files up to 30MB and 250 pages. Sending longer documents in batches of 20-30 pages improves reliability.
Concurrency: One transmission per account at a time. The assistant waits for each fax to reach a terminal state before starting the next.
Billing: Usage is billed to the account on its standard cycle. No prepaid balance is required.

All functionality exposed by the MCP server is also available directly over HTTP. See the API Reference for the underlying endpoints, request formats, and error codes.

Alternative setup

Installation above is the recommended approach: the server handles authentication itself and writes its own configuration. The methods below cover environments where that is unsuitable - restricted networks, configuration managed by a provisioning tool, or automated provisioning without an interactive assistant.

Command-line sign-in

The package exposes the same authorization flow as a command, for use before the server is registered with a client. Run it from the directory holding your MCP configuration:

npx fax-live-mcp login --write .mcp.json

It prints an authorization link and confirmation code, waits for approval, then writes the complete fax-live server entry - command, arguments, and a newly provisioned key - into the file given to --write, creating it if absent. As a safeguard against accidental credential disclosure, it declines to write to a file tracked by git or not covered by .gitignore; exclude the file from version control, or pass --force to override.

Editing the configuration directly

Add the following entry to the configuration file your MCP client reads, such as .mcp.json in your project directory or your client's global MCP settings file. Invoking the package through npx resolves the published version at launch rather than requiring a prior install:

{
  "mcpServers": {
    "fax-live": {
      "command": "npx",
      "args": ["-y", "fax-live-mcp"],
      "env": {
        "FAX_LIVE_API_KEY": "<publicId>.<secret>"
      }
    }
  }
}

Generate a key on the API Keys page and assign it to FAX_LIVE_API_KEY. Keys take the form <publicId>.<secret> and should be excluded from version control. Leaving the variable unset is also valid - the server will start without it, allowing sign-in to be completed from the conversation as described under Installation.

Restart your MCP client once configured, then ask your assistant to verify the Fax.live setup to confirm the key is accepted.