What Docusign's switch from Seats to Consumption gets right — and what's still missing

I've built pricing around agreement and revenue-management software for B2B SaaS vendors twice now: first for the revenue-lifecycle suite of products (CLM, CPQ, docgen, and eSign) at Conga, and now for Propper's eSign offering and our growing platform of document-automation functionality. In both cases, one decision mattered more to me than any other, and it wasn't how much to charge. It was what to charge for. In the pricing world, the distinct unit that carries the price is called a pricing metric, and it is the backbone of any pricing strategy.

Docusign, like countless other vendors in the B2B SaaS landscape, is re-calibrating its pricing metric to better align with customer value. It dropped the old-SaaS, per-seat model and moved to a consumption model for its largest customers, the enterprise IAM buyers: you buy credits that represent "events," you add as many users as you want, and you buy more volume when you run out. Structurally, consumption-based pricing is the correct direction, and I'd rather say so than pretend a competitor got it wrong. The seat lost its connection to value a long time ago, especially in an era where the people who drive the most volume on a platform are often the ones who never log in. As software takes over more of the work of creating and sending documents on its own, through AI agents and workflows, a per-user price reflects almost none of the value the customer actually receives. That shift is already underway at many businesses, and the seat-based pricing the largest SaaS vendors built their models around is starting to give way.

So the de facto seat-based pricing and licensing model is finally on its way out. What's worth exploring is the detail underneath, because "not a seat" still leaves plenty of room to fall into the same old traps — and how best to shake those issues is where the real pricing work begins.

First, some vocabulary

Pricing arguments get muddy because two different mechanics often compete when the word "pricing" comes up. Distinguishing them is most of the strain, so it's worth thirty seconds of taxonomy before I share my thoughts.

The licensing and billing model — how you pay. Three common shapes:

• Credits — a license to consume, bought up front. You buy a balance, and each action burns it down. Docusign's new enterprise model is this: the teardown that prompted this piece describes a bucket of credits you buy up front and spend as you send, convert, and verify.
• Usage — pay as you consume, billed in arrears for what you actually ran, like a utility.
• Commitment — you commit to a quantity for a term at a discount, with overages billed on top. Propper's SaaS agreement model is this.

The pricing metric — what you count. The unit that carries the price, and the backbone of the whole strategy. Two families:

• Access metrics — seats, users, modules. You pay for the right to log in, whether or not you do anything with it.
• Consumption metrics — events, documents, API calls, completed agreements. You pay for activity.

The shift everyone is making is from an access metric (the seat) to a consumption metric (events). What actually separates a genuine value-based model from a repackaged offering is which consumption event you count, and whether the buyer can see and translate its price.

What makes a metric value-based is simple to state and hard to hold on to: it moves with the value the customer both receives and perceives. Think of a completed agreement, a delivered message, or a processed payment. You pay only when you got the outcome you were shopping for. A seat (you pay for access, not outcomes), a document sent (you pay for attempts, including the ones that failed), and an opaque composite credit (you pay for a unit you can't tie to an outcome) each miss that mark in a different way.

Do you charge when a document is sent, or when it's signed?

As of mid-2026, Docusign's credits are purchased up front and act as a license to consume events, and on the metered surfaces an event is subtracted from your balance when a document is sent for signature, not when it gets signed. (Their published rates and allowances shift, so treat the specific figures here as a mid-2026 snapshot.) That one detail is what keeps their new consumption pricing from being a truly value-based strategy, because the moment you operate at the scale that needs automation, you pay on the attempt.

Docusign is explicit about it: for its envelope allowances, once an envelope is sent it counts "whether or not the envelope is signed or completed", and the same debit-on-send governs IAM's automation sends. The one reprieve is that correcting an envelope in flight, before it completes, doesn't add to the count.

At Propper, I've made this call in both directions. While designing our Sign pricing, the first question on the table was whether to count a sent agreement or a signed one: the moment it goes out, or once the job is done. We decided to count the result, so you pay when an agreement is completed, not for the versions it took to reach the final one or the requests that never got executed.

Docusign charging on send brings back the exact problem the old per-user model had with its envelope quotas. If the meter runs the moment you hit send, you pay for the deal that fell through, the document nobody opened, the typo fix, and the resend, none of which produced any real value for your business. A best-of-breed consumption model ties the bill to the value the customer actually gets. Charging for attempts undermines that mutual benefit and the fairness the customer perceives, and it stifles adoption by creating needless caution about how and when to use the product, even at the expense of the customer's own productivity.

A credit doesn't tell you what a signature costs

To Docusign's credit, the rate card is thoughtful. Here's how Rob Litterst described it in his teardown:

The rate card itself is the interesting part: rather than chasing tokens or word counts (the easy thing), they linked credits to output metrics that align with customers' value, and that the customer could actually estimate before signing the contract. Some notable ones:

• Documents sent for signature. The core business activity. Customers know this number.
• Converting a flat PDF into an "intelligent agreement." This is the transformation step where a dumb document becomes searchable, queryable, structured data in Docusign's intelligent repository, Agreement Manager.
• Signer authentication. The security layer customers care about and can size.

Once a document is converted into an intelligent agreement, you can search it and ask questions without consuming credits. Working on contracts, editing terms and conditions, sending agreements via SMS — none of it consumes credits right now.

Those are sensible units, and choosing them over raw tokens was the right instinct. The problem is what happens when you bundle them into a single credit currency. Committing to a block of volume up front is fine, and plenty of good models do it, ours included. The real question is what the block is denominated in, and whether you can translate that into the outcome you're actually shopping for.

In the enterprise credit model the teardown describes, that block is a bucket of credits, and a credit isn't tangible like a dollar or a signed agreement. Sending a document, converting one into structured data, and verifying a signer's identity each draw down some amount of it, but how much, Docusign doesn't say. Litterst broke the model down from an interview with the team that owns its pricing, and even he can only tell you what consumes credits, not what each action costs, because those weights aren't published anywhere. If the analyst who got that briefing can't put a number on it, the buyer certainly can't. Measured against the value-based bar, that fails on legibility: you can't see what a balance buys in the unit you actually care about, completed agreements, so you can't forecast it either. And because the bucket pools across every seat and the full multi-year term, one number is left to stand in for years of mixed activity across the whole company. Every renewal becomes a modeling exercise, and procurement ends up negotiating over a number nobody in the room can pin down.

This isn't unique to Docusign. Opaque composite credits are spreading across the category as vendors bolt more AI actions onto the same meter. It's the same problem the major AI providers now have with tokens: two people can burn through the identical number of tokens and walk away with wildly different outcomes. When the unit you're buying isn't anchored to a measurable outcome, there's no honest way to tie the price back to the value you got.

We ask customers to commit to volume too, and under our SaaS agreement model that volume resets on the same cadence, so I won't pretend our model has no trade-offs. The difference is what you're counting. A Propper commitment is denominated in completed agreements at a per-document price we publish, so you know what you bought and what each outcome costs before you sign anything.

That legibility has a practical upside a credit bucket can't copy. Every unit prices off the same published volume table, where a larger commitment earns a lower per-unit rate, and there are no hidden credit weights or automation premiums stacked on top of it. When you go past what you committed to, those extra units are priced from that same table, not moved into a separate penalty column — you simply stop earning the commitment discount on them and pay the standard published rate. That is a deliberate design choice, and I think it holds up as fair in both directions.

• For the customer, the overage is a number you can read and forecast before you sign: you commit to a floor you're confident in, and you can grow past it without a surprise waiting on the invoice.
• For us, the discount stays attached to the commitment that earns it, so you're rewarded for sizing that commitment honestly rather than under-committing and living on overflow, and in exchange for the volume you do commit, we pass the discount back.

One more difference, and this one runs in our favor. Docusign's allowance is a per-period grant, pooled across your seats and, in a multi-year deal, the whole term, so you're not racing a yearly clock. But it doesn't carry over: as a Docusign employee put it in their community forum, unused allowance is gone at the end of the term. Our pay-as-you-go credits work the other way. You buy them, and as long as you keep a core subscription they stay yours until you spend them, however long that takes. It's one of two shapes we offer, alongside the committed volume above: pay as you go when you'd rather not commit, or commit for the discount when you can, and either way, what you paid for doesn't expire at renewal.

Automation isn't an enterprise feature anymore

The same teardown pins down why the seat broke at the top of the market:

IAM launched with per-user pricing, the standard in SaaS. And to be fair, that model still works for a huge slice of Docusign's nearly 1.9 million customers (eSign and IAM) — small teams, web buyers, the entrepreneur using it to close ten deals a year. But two things broke at the top of the customer pyramid. The first was automation. A lot of users at Docusign's largest enterprise customers don't actually log into Docusign.

You can watch this happen in Docusign's own IAM allowances. Sends from the web app are unlimited, but automation sends carry a published allowance of just 100 per user per year, pooled across the account, and that cap covers API calls, customer-built integrations, workflows fired through the API, bulk send, and web and power forms. So a person clicking send in the browser is unlimited, while the identical agreement fired by your own code is metered. That's a tax on the exact automation the rest of the market is building toward.

Our position is that a completed agreement is a completed agreement. It shouldn't cost more because of how it got sent, whether that's a person clicking in the app, an integration or an agent firing it through our API, or a record in your CRM kicking one off. The outcome is the same, the value unit is the same, and the price we publish is the same. We don't keep one kind of credit for people and another for machines, because no version of the work is worth more just because software did it.

Charging a premium for those paths used to be defensible. In 2026 it isn't, because APIs and automation are no longer an enterprise carve-out. They're how all of us work with software now. I've built a handful of small automations with Claude in my own side projects, because it's gotten that easy — a nightly job that checks my home server and emails me if anything looks off, for one. Plenty of people are relying on APIs without even knowing it. If individuals are building automations on a weekend, charging a business a premium to send an agreement through an API is billing for something that stopped being special a long time ago.

Metering the channel also works directly against you. The seat is dying because it couldn't measure how software actually gets used now: through the UI, an API, an agent, or a scheduled integration, sometimes all of them for a single customer in one week. A consumption metric is what finally lets all of that count as one thing, and you keep that advantage only if the price is identical across every channel. Meter the API higher, and you've taken the one model that fits how people actually work and used it to tax your own adoption.

If you can't publish the price, the work isn't finished

Docusign publishes what it meters, but not what IAM Enterprise costs. That tier is sold through enterprise reps, and a salesperson has to help you estimate your usage before you can sign anything.

I read that as half a change. A modern consumption metric wrapped in an old-SaaS, rep-gated motion still leaves the buyer where they started, unable to reason about the price on their own. That goes double for the part most vendors bury: what a document costs once you're past what you committed to. The overage is where a buyer carries the most risk, so it's a number they want to see before signing.

To be fair, enterprise deals still need a human for negotiation and procurement, and that's fine. The rate card and the overage math, though, are separate from the negotiation, and they should be public even when the contract is sales-assisted. The bar I hold Propper's pricing to is that someone can open our pricing page and work out their own bill — base, volume, and overage — before they ever contact us.

That isn't only kinder to the customer; it's the cheapest trust you'll ever earn. A prospect who reads your whole price (base, usage, and overage) before they ever contact you walks into the conversation already halfway sold. Keep the number behind a rep, and you've traded that away for a discovery call.

What actually makes a usage model fair

Dropping the seat is the licensing shift, and Docusign made it. The pricing metric is where it stopped short. Held against the three tests a genuinely value-based model has to pass, the new model fails all three:

• The unit. It meters the send, not the outcome, so you still pay for the attempts, the bounces, and the deals that fell through.
• The legibility. The price is denominated in composite credits rather than in the agreements you came to buy, so you can't translate a balance into value.
• The visibility. It stays behind a rep, overages and all.

Compare that to Propper's model viewed through the same lens:

• The unit. We count the completed agreement, not the send, so you never pay for an attempt.
• The legibility. We denominate the price in those completed agreements at a rate we publish, so a number on the page always translates into the outcome you came for.
• The visibility. We put the whole rate card — base, volume, and overage — in front of you before any conversation starts.

Underneath those three answers is a single decision: we strip out the things other models charge for that don't create real value — the seat, the tiered editions, the automation premium. Each was a charge we could have kept, and we gave it up on principle, betting that growing with our customers on a fair, legible exchange beats collecting on friction.

Signing is a commodity being priced as a luxury

The choice of number matters beyond any single renewal, because a pricing metric decides more than how a bill gets divided — it decides how much of the market ever gets to use what you built. Economists have a name for the underlying dynamic, the Jevons paradox: the total use of a technology tends to rise, not fall, as it becomes cheaper and easier to apply, because the efficiency opens up uses that were never worth it before, and that expansion outweighs the lower per-unit price. Coal consumption climbed as steam engines grew more efficient. Computing went from a handful of million-dollar mainframes serving a narrow set of problems to something we now spend on without a second thought, on problems no one would have dedicated a machine to a generation ago, and the industry grew by orders of magnitude as the cost per computation collapsed.

Electronic signature belongs in that same lineage. It has become a commoditized capability: every business needs it, whatever their size, industry, or how complicated their agreements get, and at that point it behaves less like a premium feature and more like a consumable input, part of the basic fuel a business runs on. The category is already forecast to keep growing. I think it would grow further, and reach further into smaller businesses and into the everyday agreements that larger companies with a signing tool never bother to send, if the economics were friendlier than the seat-and-envelope pricing the market inherited. A metric that charges for the outcome instead of the access, priced so a buyer can read it and commit to a floor they can grow past without fear, is the version of this technology the widest part of the market can actually afford to put to work.

Signing is already necessary, whether you're closing a big deal with a client or onboarding new talent. So the question worth asking is a simple one: how much is that completed agreement worth to you?