E-Signature API Pricing in 2026: How Providers Actually Charge

Published 2026-08-18 — by Efren Medina, Founder of Contract Flash

TL;DR

• Three meters dominate: per envelope, per seat, and per API call. The meter matters more than the headline number. Two quotes with similar monthly prices can differ several-fold once your real volume runs through them.
• Verified list prices, 2026-08-18. Docusign Developer: Starter $50/mo (40 envelopes/mo), Intermediate $300/mo (100/mo), Advanced $480/mo (100/mo). Dropbox Sign API: Essentials $75/mo (50 requests/mo), Standard $250/mo (100/mo). BoldSign Enterprise API: $0.75/envelope, $30/mo minimum including 40. SignWell: from $0.85/document, down to $0.20 at volume, with up to 25 free API documents a month by tier. Anvil: $1.50 per e-sign packet, dropping to $0.67 at 50,000+. Documenso: API on plans from $25/mo, or self-host the AGPL-3.0 build.
• The trap is the allowance, not the price. Allowances are usually monthly or annual; volume is seasonal. Ask what the overage rate is, and whether reminders, resends, voided envelopes, and sandbox traffic count.
• Sometimes you shouldn't buy an API at all. If you'd end up rebuilding storage, status tracking, reminders, and a repository around the signing primitive, a platform with signing included is usually cheaper in total.
• Where Contract Flash fits, honestly: signing is included on every plan with no per-envelope fee — 3 signature requests a month on the free plan, unlimited on paid plans — and programmatic sending exists — but through an MCP (JSON-RPC) endpoint, not a conventional REST e-signature API. There is no embedded signing iframe, no per-event webhooks, and no sandbox environment today. If you need those, buy Dropbox Sign, BoldSign, SignWell, or Docusign. That's the accurate answer.

If you're pricing an e-signature API, you're really doing a unit-economics exercise disguised as a vendor comparison. Here's the honest version of both.

The three meters

1. Per envelope (or per document, or per packet). You're charged for each package sent for signature, regardless of how many signers it contains or how many times it's viewed. Docusign, Dropbox Sign, BoldSign, SignWell, and Anvil all meter this way at some level. It's the easiest meter to model and the easiest to blow through.

2. Per seat (sender account). You're charged per sending user, usually with an envelope allowance attached. Common in web-app plans; less common in pure API plans, though several vendors bundle "application users" into API tiers. This meter punishes teams and rewards single-integration architectures.

3. Per API call / per transaction. Charged for programmatic volume, sometimes in prepaid blocks with volume discounts. It's the fairest meter for high-volume embedded use and the most annoying to forecast.

Most vendors combine two of the three. That combination is where the surprises live.

What providers actually charge

Every figure below was verified against the vendor's own pricing page on 2026-08-18. Prices change frequently; confirm before you commit.

Two things stand out. First, Docusign is roughly an order of magnitude more expensive per envelope than the specialists at low volume — $300/month for 100 envelopes/month is $3/envelope before you've written any code, versus BoldSign's $0.75. Second, the vendors that publish an overage rate are doing you a favor. BoldSign, SignWell, and Anvil publish theirs. Docusign and Dropbox Sign route overage through sales, which means your marginal cost is a negotiation, not a number.

Model your cost before you talk to anyone

Work out these five numbers first. They determine everything.

1. Annual envelope volume. Not documents, not signers — envelopes. A three-signer MSA is one envelope on most meters.
2. Peak-month volume. If you do 40% of your annual volume in Q4, a monthly allowance is a very different product than an annual one.
3. Sending accounts. How many distinct senders or application users the integration needs. On seat-metered plans this is the whole cost.
4. The overage rate. Get it in writing. This is where budget surprises come from.
5. What counts. Ask explicitly: do reminders count? Resends? Envelopes the recipient declined? Voided envelopes? Sandbox and test traffic? Answers vary by vendor and are rarely on the pricing page.

A worked example

2,000 envelopes a year (≈167/month), two sending accounts, US-only, no identity verification. Arithmetic on published list prices — not quotes, and not including negotiated discounts:

The spread between the cheapest and most expensive credible option here is roughly 7×, for the same 2,000 signatures. That's the argument for doing the arithmetic before the demo.

The traps

• Annual allowances against seasonal volume. An allowance of 1,200 envelopes a year is not the same product as 100 a month if your business is lumpy. Ask which one you're buying.
• Per-seat creep on API plans. Some API tiers bundle a small number of "application users." If your architecture needs a sender identity per business unit, that's a per-seat bill hiding inside a per-envelope plan.
• Sandbox billing. Most vendors offer a free developer sandbox — Dropbox Sign has a free test mode, BoldSign a free sandbox. Confirm yours is genuinely free before you write load tests.
• Feature gating below the price you were quoted. Embedded signing, custom branding, webhooks, and bulk send are commonly gated to higher tiers. Price the tier that has the feature you're integrating, not the entry tier.
• The renewal ratchet. Multi-year enterprise agreements frequently reset allowances upward at renewal. Buyers of the former PactSafe clickwrap product reported exactly this pattern after its acquisition. Ask what happens at renewal if your volume grew 3×.
• The integration is the real cost. A per-envelope fee of $0.75 on 2,000 envelopes is $1,500/year. Two engineer-weeks building and maintaining the integration costs more than that. Price the work, not just the meter.

When you shouldn't buy an e-signature API at all

Buying the signing primitive makes sense when you already have the surrounding system: a place documents live, something that tracks status, something that sends reminders, something that knows when the agreement renews. If you have all of that, an API is exactly the right purchase, and one of the specialists above will serve you well.

If you don't have that system, an API purchase quietly commits you to building one. The cost shows up as: a documents table, a status webhook consumer, a retry queue, a reminder scheduler, a storage bucket with a lifecycle policy, an audit view for the legal team, and a CSV export nobody scoped. That's the expensive part, and it's why "we'll just use the API" so often turns into a two-quarter project.

Where Contract Flash fits — and where it doesn't

Contract Flash includes native ESIGN/UETA e-signature on every plan, with no per-envelope, per-signer, or per-signature fee anywhere. The $0 free plan sends 3 signature requests a calendar month; every paid plan is unlimited, so signing volume does not change the bill. Sender-side field placement, multiple signers with sequential or parallel ordering, decline, delegate, void, expiry, automatic reminders, and a Certificate of Completion on every executed document are all included, and the executed PDF files itself back into the repository with its dates on the calendar.

Programmatic access exists, and it is not a REST e-signature API. Being precise, because this is the section where vendors usually get vague:

• The interface is an MCP (Model Context Protocol) endpoint — JSON-RPC 2.0 at POST /api/mcp/v1. It's the same endpoint the Claude integration uses.
• Auth is either an OAuth 2.0 authorization-code grant with PKCE, or a first-party API token you issue yourself from Settings → Developer. Scopes are read:contracts, write:contracts, and admin:contracts, and token scopes are capped by the issuing user's role.
• Sending is one tool call: cf_send_for_signature, taking the contract or draft id, a signer list with optional ordering, a subject, optional CC recipients, and a signing mode of sequential, parallel, or in_person. cf_get_signature_status returns per-signer status for every request ever issued against a contract. Sends made this way draw on the same plan allowance as sends made from the app.
• What does not exist today: an embedded signing iframe for your own UI, per-event webhooks for signature lifecycle events, a separate sandbox tenant, and a published OpenAPI spec for a general REST surface. If your integration depends on any of those, Contract Flash is the wrong tool and one of the specialists above is the right one.

So the honest positioning is: Contract Flash is a good answer if you want signing included in a contract platform and occasional automation on top, and a poor answer if you're embedding signing into your own product's user experience. Those are different purchases.

Frequently asked questions

How is e-signature API pricing usually structured?

Three meters dominate. Per-envelope pricing charges for each document package sent for signature, regardless of how many signers it has. Per-seat pricing charges for each sender account, usually with an envelope allowance attached. Per-API-call or per-transaction pricing charges for programmatic volume, often in prepaid blocks. Many providers combine two of the three, which is why two quotes with similar headline numbers can differ several-fold in practice.

What should I model before signing an e-signature API contract?

Model annual envelope volume, peak-month volume, the number of sending accounts, and the overage rate that applies once an allowance is exhausted. Overage is where most budget surprises originate, because allowances are typically annual while volume is seasonal. Also check whether reminders, resends, and voided envelopes count against the allowance, and whether sandbox and test envelopes are billed.

Is an e-signature API cheaper than a contract platform with signing built in?

It depends on whether you also need the surrounding workflow. An API alone is cheaper if you already have a system that stores documents, tracks status, and handles reminders, and you only need the signing primitive. If you would end up rebuilding storage, audit trails, reminders, and renewal tracking around the API, a platform that includes native signing is usually cheaper in total cost, because the integration work is the expensive part rather than the per-envelope fee.

Do I need a separate e-signature vendor if my contract system already signs documents?

Usually not, provided the built-in signing meets the same legal standard. In the United States that means compliance with the ESIGN Act and UETA: demonstrated intent to sign, association of the signature with the record, and a retrievable audit trail. If the built-in signing produces a Certificate of Completion with those elements, a second vendor mainly adds cost and a second place for signed documents to live.

What is the cheapest e-signature API in 2026?

At moderate volume, BoldSign's $0.75 per envelope with a $30/month minimum and SignWell's per-document pricing from $0.85 down to $0.20 at volume are the lowest published list rates among hosted providers. Self-hosting Documenso, which is licensed AGPL-3.0, has no per-document licence cost at all, but you take on the infrastructure and operations. Anvil publishes $1.50 per e-sign packet with volume discounts to $0.67. Docusign and Dropbox Sign sit at the expensive end for low-volume API use.

How much does the Docusign API cost?

Docusign's published Developer plans as of 2026-08-18 are Starter at $50/month or $600 billed annually with a starting allowance of 40 envelopes per month; Intermediate at $300/month or $3,600 annually with 100 envelopes per month; Advanced at $480/month or $5,760 annually with 100 envelopes per month; and an Enhanced tier with custom pricing and custom envelope limits. Overage rates are not published on the plan page and are set through sales, so the effective per-envelope cost above the allowance has to be negotiated.

Does Contract Flash have an e-signature API?

Not a conventional REST one. Contract Flash exposes an MCP endpoint — JSON-RPC 2.0 at /api/mcp/v1, authenticated with OAuth 2.0 or a self-issued API token — that includes tools for sending a contract or draft for signature and for reading per-signer status. There is no embedded signing iframe, no signature-event webhooks, and no separate sandbox environment today. Teams that need to embed signing inside their own product should use a provider built for that; teams that want signing included in a contract platform, with automation available on top, are well served.

What does e-signature cost with Contract Flash?

Nothing extra. Native e-signature is included in every Contract Flash plan rather than metered per envelope, from the $0 free tier through the $59, $149, and $349 per month paid plans. The free plan sends 3 signature requests per calendar month; every paid plan is unlimited. There is no per-envelope charge and no separate signing add-on, so signing volume does not change the bill.

Are per-envelope fees ever the better deal?

Yes, at genuinely low volume. If you send twenty envelopes a year, $0.75 each is $15 and no subscription beats that. Per-envelope pricing stops being the better deal at the point where the annual meter exceeds a flat plan. Against a $149/month platform ($1,788/year), the crossover lands near 600 envelopes a year at Docusign Intermediate's effective rate of roughly $3 per envelope, and near 2,400 a year at BoldSign's $0.75. Do that crossover calculation with your own numbers; it's a five-minute exercise that frequently reverses a purchase decision.

Related reading

• Product overview: Native e-signature in Contract Flash
• Buying for a small team: Best E-Signature for Small Business in 2026
• One-to-many acceptance: Clickwrap Agreement Software: What to Look For in 2026
• Free and low-cost tools: Does Anybody Offer a Free E-Signature Tool or DocuSign Alternative?
• Total cost of ownership: What Are the Most Cost-Effective Contract Management Systems in 2026?

If your conclusion from the arithmetic above is "I need an embedded signing API," go buy one of the specialists — that's the right call and this article was meant to help you make it. If your conclusion is "I mostly need signing to be included and to stop paying per envelope," Contract Flash's free plan includes signing at $0 — 3 signature requests a month, no card — and the e-signature overview describes exactly what's in it. Start free or read about the Claude/MCP integration if the automation path is what interests you.

Last updated 2026-08-18. All competitor pricing verified against each vendor's own pricing pages on that date and subject to change — confirm current rates directly before purchasing. Cost estimates are arithmetic on published list prices, not quotes, and exclude negotiated discounts, taxes, and add-ons.