Document Workflow Automation: Where Faxing Fits (2026)

By Sarah Martinez · Published November 9, 2026 · 11 min read

Quick answer: To automate document workflows, pick one document type, map the path it takes, and give each stage a tool: capture → classify and extract → route and approve → sign → deliver → archive. Fax still has two jobs in that chain. It is an intake channel when partners fax you, and a delivery step when a partner only accepts fax. Both can run without a person over the mFax API.

Most guides to document workflow automation stop at e-signatures and approvals. Real workflows have messier ends. Referrals, prior authorizations, signed contracts and vendor forms still arrive by fax, and some recipients still want one back. If those two ends stay manual, someone is still printing, scanning and retyping in the middle of your "automated" process.

This guide is vendor-neutral for the six stages. Then it shows how to wire the fax ends into the same pipeline with mFax, a fax service whose REST API is included with mFax Business.

What Is Document Workflow Automation?

Document workflow automation is software moving a document through a defined set of steps (intake, data capture, review, approval, signature, delivery and storage) without a person handing it along at each step. People still make the decisions that need judgment. The software handles the handoffs, the data entry and the record-keeping.

An automated document workflow differs from a document management system. A DMS stores documents and controls who can open them. A workflow decides what happens to a document next: who reviews it, which system receives its data, where the signed copy goes and how long it is kept. Most teams need both, connected.

It also differs from a single tool. "We use e-signatures" automates one stage. A whole automated workflow covers the path from the moment a document arrives until it is filed.

The payoff comes in three places:

• Fewer handoffs. Documents stop waiting in someone's inbox for forwarding.
• Less retyping. Data read once from a document flows into your CRM, EHR or ERP.
• A trail. Every step leaves a timestamped record, which matters when an auditor or a client asks what happened to a document.

The Six Stages of an Automated Document Workflow

Every document workflow, whatever the industry, passes through the same six stages. The tools differ by stage, so plan stage by stage before you pick software.

Two stages carry most of the risk. Extraction is where wrong data enters your systems, so it needs confidence thresholds and human review. Delivery is where a document leaves your control, so it needs proof that it arrived.

Capture and Intake

Intake is any channel through which documents reach you, and every channel should end in the same place: one queue with one record per document. Typical channels are a shared mailbox, an upload form, a scanner and a fax number. If you are digitizing paper at a front desk, our guide to scan to email covers the scanner side.

Classify and Extract

Classification decides what a document is; extraction reads the fields you need from it. OCR turns the image into text. An IDP tool or a set of templates then maps that text to fields. Fax pages are lower resolution than a fresh scan, so set a confidence threshold. A field below it goes to a person, not into your database.

Route and Approve

Routing applies your business rules to the extracted data. For example: invoices under a set amount go to one approver, contracts with non-standard terms go to legal, and referrals go to the scheduling queue for the right location. Most teams build this in an iPaaS tool or in the workflow engine their main system already has.

Sign

E-signatures automate the signing event, not the workflow around it. In the US, the ESIGN Act says a signature, contract or other record relating to a transaction may not be denied legal effect solely because it is electronic. When the counterparty needs the signed copy by fax, our Docusign fax guide walks through that handoff.

Deliver

Delivery is the last step you control, so it needs a confirmation you can store. Email gives you "sent". A portal gives you "uploaded". A fax gives you a delivered or failed status from the receiving end. Whichever channel you use, write the result back to the document's record.

Archive

Archiving means storing the final document with its metadata, and deleting it when its retention period ends. Retention periods come from the rules your documents fall under. For tax records, the IRS says to keep most records for 3 years, and employment tax records for at least 4 years (IRS: How long should I keep records?). HIPAA requires keeping your security policies and procedures documentation for 6 years (45 CFR 164.316). That rule covers your documentation, not every record you process, so confirm the periods with whoever owns compliance.

How to Automate Document Workflows in 7 Steps

Start with one document type, automate the boring handoffs first, and keep a human in the loop for exceptions. These steps work the same whatever tools you choose.

Where Faxing Fits in a Document Workflow

Fax sits at the two ends of many document workflows: as a channel documents arrive through, and as the way they must leave for some recipients. Healthcare is the clearest case. On the U.S. government's health IT data page, 40% of hospitals said they often sent patient health information by mail or fax in 2025, and another 34% sometimes did. On the receiving side, 35% often and 46% sometimes received it that way (ONC, Methods Used by Hospitals to Engage in Interoperable Exchange). The survey counts mail and fax together, but the point for workflow design stands: your partners decide the channel, not you.

So a document workflow that touches clinics, insurers, courts, government offices or older vendors has to handle fax at both ends. Our fax automation guide covers fax-only workflows in depth; this section is about plugging fax into a broader document pipeline.

Fax as an Intake Channel

Treat an inbound fax as a PDF that arrived through a different door. Give it a record in the same intake queue as email and uploads, then send it through the same extraction and routing. What changes is the source metadata: the sending number and the time it arrived.

Fax as a Delivery Step

Treat an outbound fax as one delivery option your routing step picks per recipient. If the partner record says "fax only", the workflow renders the final PDF and sends it to their fax number. The fax's final status, delivered or failed, then goes back on the document's record, and a failure goes to the exception queue.

How to Automate the Fax Steps Over the mFax API

The mFax API sends a PDF with one request and reports what happened through webhooks, so both fax ends of your workflow run from code. It is a first-party REST API, documented at developers.mfax.to. Requests go to https://developers.mfax.to/v1 with a Bearer API key that the workspace owner creates in the mFax dashboard. Keep the key on your server.

Step 1: Send the Delivery Fax

Your delivery step posts the final PDF and stores the returned uuid against your own document ID. The request takes only two fields:

curl -X POST https://developers.mfax.to/v1/faxes \
  -H "Authorization: Bearer $MFAX_API_KEY" \
  -F "to=+15417543010" \
  -F "file=@referral-packet.pdf"

In a workflow you'll call it from code. This Python version handles rate limits and keeps the link between your document and the fax:

import os
import time
import requests

API = "https://developers.mfax.to/v1/faxes"
HEADERS = {"Authorization": f"Bearer {os.environ['MFAX_API_KEY']}"}

def fax_document(doc_id, pdf_path, to_e164):
    for attempt in range(5):
        with open(pdf_path, "rb") as f:
            r = requests.post(
                API,
                headers=HEADERS,
                data={"to": to_e164},
                files={"file": (f"{doc_id}.pdf", f, "application/pdf")},
            )
        if r.status_code == 429:  # rate_limited: wait as long as the API asks
            time.sleep(int(r.headers.get("Retry-After", "5")))
            continue
        if r.status_code == 202:
            fax = r.json()
            save_fax_id(doc_id, fax["uuid"])  # your database: one document, one fax
            return fax
        err = r.json()  # {"code": ..., "message": ...}
        raise RuntimeError(f"{err['code']}: {err['message']}")
    raise RuntimeError("still rate limited after 5 attempts")

Storing the uuid before you do anything else is your protection against sending the same document twice. Before a retry, look up whether this document already has a fax, and check its status instead of posting again.

Step 2: Receive Events With a Webhook

Webhooks push fax.delivered, fax.failed and fax.received to your server, so your workflow reacts as soon as something happens. You set the webhook URL, and optionally a signing secret, in the mFax dashboard. Each POST is an envelope with an id, a type, a unix created time and data, which is the fax object.

Two rules make the handler safe:

• Dedupe on the event id. Delivery is at-least-once, so the same event can arrive twice.
• Verify the signature when you've set a secret. The X-Zelda-Signature header has the form t=<timestamp>,v1=<hex>, an HMAC-SHA256 of the timestamp, a dot and the raw body. The docs' sample rejects timestamps older than 5 minutes.

import express from "express";
import crypto from "node:crypto";

const app = express();

function verify(secret, header, rawBody) {
  const [t, v1] = header.split(",").map((p) => p.split("=")[1]);
  if (Math.abs(Date.now() / 1000 - Number(t)) > 300) return false;
  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${t}.${rawBody}`)
    .digest("hex");
  return v1.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(v1), Buffer.from(expected));
}

app.post("/webhooks/mfax", express.raw({ type: "application/json" }), async (req, res) => {
  const raw = req.body.toString("utf8");
  const sig = req.get("X-Zelda-Signature");
  if (!sig || !verify(process.env.MFAX_WEBHOOK_SECRET, sig, raw)) {
    return res.sendStatus(401);
  }

  const event = JSON.parse(raw);
  if (await alreadyProcessed(event.id)) return res.sendStatus(200); // at-least-once

  const fax = event.data;
  switch (event.type) {
    case "fax.received": // intake: a new document entered the workflow
      await intakeQueue.add({ source: "fax", faxId: fax.uuid, mediaUrl: fax.media_url });
      break;
    case "fax.delivered": // delivery confirmed: close this step on the document
      await markDelivered(fax.uuid);
      break;
    case "fax.failed": // delivery failed: hand it to a person
      await exceptionQueue.add({ faxId: fax.uuid, reason: fax.failure_reason });
      break;
  }
  await markProcessed(event.id);
  res.sendStatus(200);
});

intakeQueue, exceptionQueue and the other helpers stand in for your own queue and database. For inbound faxes, download the file promptly: media_url is a presigned, time-limited link. Then the PDF goes through your normal extraction and routing like any other document.

Step 3: Handle Errors and Reconcile

Every API error comes back as JSON with a code and a message, and each code maps to a different action in your workflow.

A failed fax is different from a failed request. The request succeeded, but the fax ended as failed, with a failure_reason such as user_busy. Route those to your exception queue and decide there whether to resend.

Webhooks can be missed if your endpoint is down. A nightly job that lists recent faxes with GET /v1/faxes?since= and compares them with your records catches anything that slipped through.

Using an AI Agent Instead of Writing the Glue

If your team builds workflows with AI agents, the mFax Skill gives the agent the API's instructions. It is a Markdown file you drop into Claude Code, OpenClaw or another skill-aware agent, and the agent can then send and track faxes through the API without glue code.

Common Mistakes When You Automate a Document Workflow

Most failed automation projects fail at the edges: the channels and exceptions nobody mapped. Watch for these:

• Automating the middle and leaving the ends manual. If faxes still arrive on paper, someone still types them in. Count every intake and delivery channel in step 2.
• No exception owner. A document the rules can't place must land in a queue with a named person, not in a log nobody reads.
• Trusting extraction blindly. OCR on low-resolution pages makes mistakes. Send low-confidence fields to review.
• Polling instead of events. Checking a status every minute wastes requests and adds delay. Use webhooks, and keep polling for reconciliation.
• Losing the proof. If the delivery confirmation isn't stored with the document, you can't answer "did they get it?" a month later.
• Sending twice. Retries without a stored ID can fax the same packet to a partner twice. Link every send to your document ID.

If your workflow centers on one system, our guides to fax integration and Salesforce fax integration show where the fax step plugs into common business software.

No-Code Options for the Fax Step

If you don't have developers, you can still take fax off paper. The mFax app sends and receives faxes from a phone, a computer or a browser, and you can try it free for 7 days. On mFax Business, every member can also fax from their email by sending a message to the fax number at send.mfax.to (for example 12125550147@send.mfax.to) from the address they sign in with. Neither gives you the webhooks and status events an automated workflow runs on, so for a full pipeline, use the API.

Start Building

Map one document type this week and list its intake and delivery channels. If fax is on either end, see what one request looks like on the mFax API page, then read the reference at developers.mfax.to. API access is included with mFax Business, at about 4¢ a page with no separate API fee. For code in more languages, our send fax API tutorial and fax API overview go further.