Why Your Next SaaS Product Should Charge by the Second, Not the Seat

When it comes to pricing your SaaS product, it's worth taking a closer look at how you're structuring those charges. Charging by the seat has been the norm for quite a while, but what if there’s a better way? Enter charging by the second. Here’s why this approach might just make sense for your next product.

1. Flexibility is Key

Imagine your users only pay for what they actually use. With a per-second billing structure, customers won’t feel like they’re wasting money on seats they might not always need. They get the flexibility to adjust their usage without worrying about a flat rate that sometimes feels like a gamble.

2. Attract a Broader Audience

Charging by the second can appeal to startups and smaller teams that are cautious about their spending. They can dip their toes in without committing to a seat-based plan that could break the bank. This opens the door for a wider range of potential customers who might not have considered your product before.

3. Encourage More Usage

When users know they're only paying for the seconds they actually use, they’re more likely to leverage all the features of your product. This could lead to higher user engagement and ultimately, greater satisfaction with your software. When they see value, they’ll be more inclined to stick around.

4. Easier to Scale

As your customers grow, so do their needs. Charging by the second makes scaling simpler. Users can ramp up their usage as needed without the stress of re-evaluating their subscription plan every time they add a new team member or project.

5. Aligns with Customer Success

This model fosters a stronger relationship between you and your customers. By aligning your pricing with their usage, you're essentially saying, "We want you to succeed." When your customers know that you’re rooting for their success, it builds loyalty that a traditional seat-based model can’t match.

6. Transparent and Predictable

Billing by the second can create a more transparent pricing model. Customers can easily track their usage in real-time and understand exactly what they’re being charged for--there’s no hidden costs or surprises at the end of the month.

Conclusion

Switching to a per-second pricing model could be the game-changer your SaaS product needs. Not only does it provide flexibility and scalability for your customers, but it also encourages greater usage and fosters better relationships. Next time you're thinking about pricing, consider whether charging by the second could be the fresh approach that sets your product apart.

• The way your AI features are structured just doesn't align with user seats. When it comes to GPU minutes, tokens, CPU‑ms, and events, they don’t really fit into that straightforward “$/user/month” model. Because of this, Finance struggles with forecasting, Procurement can't effectively generate POs, and Engineers can't measure things precisely enough to justify expenses. To make matters more complicated, 73% of tools increased their prices in 2025, and the waste from unused licenses hit about $21M per enterprise. This means your CFO is pretty hesitant to commit to another static license. (saaspricepulse.com)
• The tech stack you're using already tracks costs down to the second: Google Cloud Run charges per vCPU‑second and GiB‑second; Cloudflare Workers bills based on requests and CPU‑milliseconds; and AWS has rolled out per‑second billing for more OS images. Your product can definitely follow suit--provided that your metering, billing, and settlement processes are set up to handle it. (cloud.google.com)
• Budget volatility + wasted licenses: Zylo’s indices for 2025 and 2026 reveal some serious issues with license under-utilization and a scattered approach to spending. Business units are now calling the shots on most of the SaaS purchases, which is leading to unnecessary waste and gaps in visibility. Every month that you keep those “per seat” licenses, you’re essentially covering the costs for users who aren’t even active, while missing out on maximizing the potential of your power users. Check more about it here.
• Pricing inflation and contract drag: Most vendors have sneakily raised their list prices in 2025. If you trap customers into fixed seats while the costs of your inputs (like GPU, L2 gas, and storage) are all over the place, you’re either going to lose money or hit them with unexpected charges--both of which can drive customers away. Dive deeper into this topic here.
• RevRec exposure: The mix of “base + seats” plus some soft usage add-ons can lead to some tricky variable consideration and allocation issues under ASC 606. If you’re not able to tie metered consumption back to performance obligations, auditors are going to require you to take a conservative approach to recognition, which means you could end up understating your ARR. More details can be found here.
• Missed delivery dates: Google Cloud changed its spend-based CUD model on January 21, 2026. Without near-real-time showback, you risk going over budget on CUDs, which can blow up your SOW budgets and delay your launches. Find out more here.

We’re all about swapping out seats with second-granularity pricing, making sure everything is wired end-to-end--from meter readings to quotes, cash transactions, and ledgers--using cryptographic proofs where they actually make a difference for the business. Our method combines the solid enterprise billing setup of Stripe with smooth on-chain settlement (thanks to post-EIP-4844 L2s) and zero-knowledge attestations to keep everything auditable.

1) Get Your Meters Just Right (Seconds, Tokens, CPU-ms)--No More Guessing!

• Event Capture: Start by adding OpenTelemetry-style events to your services. You’ll gather everything in Kafka or Flink and create those essential “meter events” like audio processing time, CPU milliseconds, or token counts. After you’ve got that sorted, send it over to Stripe Meters, which will act as your go-to financial record for tracking usage. Check out the full guide here.
• Pricing Models: With Stripe, you can easily set up rate cards based on per-second usage or per-100-unit packages. Plus, you can incorporate graduated or volume tiers, manage credit burn-downs, set thresholds, and create alerts. The new Pricing Plans (2025 private preview) also let you mix and match base fees, usage charges, and periodic credits--pretty vital stuff for enterprise SKUs. Dive deeper into this here.
• Guardrails: Think of it like setting up safety nets--implement customer-level caps, get those anomaly alerts in place, and establish soft limits to steer clear of any 'denial-of-wallet' moments. Plus, deliver real-time dashboards to help customers avoid those frustrating “why is my bill $127?” queries. For more on this, check out Stripe's usage-based billing.

Make Billing and Revenue Recognition Audit-Proof

• ASC 606 alignment: For stand‑ready services where pricing varies and there’s a fixed rate, you should use the “invoice practical expedient.” This means you’ll recognize revenue based on actual usage as it happens. When dealing with hybrid situations (like minimums, commitments, and credits), make sure to have clear allocation rules and rollovers in place to avoid any mix-ups. You can read more about this here.
• Worked patterns we implement:
  • Pay‑as‑you‑go only: Recognize revenue as it's consumed.
  • Minimums + overage: Use a ratable base and account for overages as they occur.
  • Prepaid credits: Defer revenue and draw it down as you consume. Check out more details here.

3) Settle in Real Time with Programmable Wallets--No User Gas Friction

• Why Now: With Ethereum's Dencun/4844 rolling out in 2024 and Pectra dropping in 2025, we've seen Layer 2 fees hit the ground. Plus, EIP-7702 has made things way easier with temporary smart-account features. This all means we can finally take advantage of per-second micro-settlement on mainstream L2s. Check out more details here.
• How We Wire It:
  • Smart Accounts: We’re using ERC-4337-style account abstraction with paymasters to cover gas fees. This way, customers can just pay in stablecoins while we take care of the gas behind the scenes.
  • Streaming: We can make money streaming happen using ERC-1620 semantics or proven protocols like Superfluid. This lets us pay and collect “by the second.” Fun fact: Superfluid has already reported over $1.4 billion streamed to around 1.18 million recipients--talk about a solid proof of concept! You can read more about it here.
  • Cheap DA and Settlement: We’re batching settlement commitments on an affordable L2 that supports blob transactions. Blob fees are in a separate market and have shown massive cost reductions compared to calldata. Dive into the details here.

4) Add verifiable usage proofs where it matters (disputes, partners, marketplaces)

• ZK‑meter attestations: When it comes to high-stakes situations--think OEM bundles or marketplace revenue sharing--it’s crucial to have some solid proof. That's where zk proofs come in handy. We create zk proofs that show your metering function f(logs) was executed correctly off-chain, and then we commit the digest on-chain to ensure non-repudiation. Thanks to recent breakthroughs in zkVM technology (like RISC Zero aiming for sub-12 second ETH proofs and Succinct’s pilots for high-throughput rollups), this is now totally doable without breaking the bank on your unit costs. Check it out here: (risc0.com)

5) Close the loop with Procurement and Finance, not just Product

• Procurement-fit invoices: Make life easier by auto-generating usage invoices and sending them over to Coupa or SAP Ariba with all the right PO/line-level mapping, tolerances, and tax codes. It’s important to get in sync with your CUD/commit logic (not just focusing on “one SKU”). Coupa and Ariba handle pricing and meter based on documents or spend, so your usage invoices won’t seem out of place for Accounts Payable. Check it out here: (coupa.com)
• Cloud commit awareness: Keep an eye on your cloud's spend-based CUD data! GCP recently changed the export schema and timing, plus there's a mandatory migration coming up on January 21, 2026. This info is crucial for forecasting your margins versus actual usage, helping you avoid any hiccups like under- or over-recovery in pricing. More details here: (cloud.google.com)

Where Blockchain Really Drives Business Outcomes (Not Just Hype)

• Lower Take-Rate for Micro-Settlement: Thanks to EIP-4844 blobs and Layer 2 economics, we’re aiming for super low settlement overhead--think sub-cent costs every session or even per second slice. This means you can price “closer to value” without getting hit by hefty fees. Independent analyses have shown that, post-4844, Layer 2s can slash their L1 data costs by over 90%. Check out more details here.
• Fewer Billing Disputes: With cryptographic receipts that combine usage digests and settlement hashes, those pesky “he-said-she-said” disagreements can be cut down. This is especially helpful in channel partnerships, minimizing days sales outstanding (DSO) issues.
• Faster Cash Flow: Streaming payments can turn accounts receivable into continuous settlements. When you mix this with prepaid drawdowns, you’ll find that your cash conversion cycles get a nice boost while customers keep control over their spending. Real-world usage at scale, like the figures from Superfluid, showcases this operational maturity. Discover more about it here.

1. Real-time Speech Analytics API, billed by the second

• Meter: We track audio duration with second-by-second granularity, sending the data out as meter events.
• Billing: We're using Stripe Meter, which means you’ll see graduated pricing tiers after you hit 1 million seconds a month. If you need more credits, you can top up through enterprise POs, and we can even handle mid-cycle rate adjustments with our flexible billing mode. (docs.stripe.com)
• Settlement: We’ll stream USDC directly to a vendor wallet on Base. Plus, your customers can keep an eye on their "credit burndown" in real-time. To keep things smooth, we cover gas fees with a paymaster, so there’s no hassle with wallets.
• Cost Control: We’ve got Cloudflare Workers in the ingestion path, which are billed per request and CPU milliseconds. To prevent any denial-of-wallet attacks, we cap CPU time per invocation. (developers.cloudflare.com)

2) Security Co-pilot Priced by CPU-Milliseconds of Scan Time

• Meter: You’ll want to track CPU-ms per scan from your serverless setup. Both Workers and Cloud Run give you the option to see costs per second or millisecond--use those as your go-to internal transfer price. You can find more details here.
• RevRec: Consider using the invoice practical expedient for pure variable usage. If you've got monthly minimums or annual commitments in play, be sure to allocate those costs clearly across your performance obligations. Check out the specifics here.
• Procurement: Don’t forget to send the monthly usage invoice along with the log digest to Coupa. Make sure to match it to the purchase order, keeping those tolerance bands in mind. More info can be found here.

3) AI Document Processing with ZK Attestation (Billed per Page-Second)

• Metering: We keep track of your usage by multiplying pages by seconds on the GPU, and we hash the data for each batch.
• Proof Generation: We create a zero-knowledge proof that ensures the math checks out--specifically, that the total page count multiplied by the time per page doesn’t exceed what you’re billed for. We also anchor the proof hash and the Stripe invoice ID on-chain. With ZK proving stacks like RISC Zero and Succinct, you can keep customer data off-chain while still verifying everything accurately.

Best Emerging Practices (Jan 2026)

• Think of seconds as your basic unit. It’s best to price packages using relatable terms like minutes or credits, but keep your internal calculations at the second level to sidestep any rounding issues.
• Keep the “metering of value” separate from “metering of cost.” This means distinguishing cost meters (like GPU‑s and CPU‑ms) from value meters (such as tokens or recorded call seconds). This way, Finance can fine-tune margins without messing with the user experience.
• Start with “soft caps and alerts” before diving into hard enforcement. A lot of usage mishaps stem from communication breakdowns, not malicious intent. Using Stripe’s alerts and dashboard visibility can help prevent those annoying support escalations. (stripe.com)
• Stream the small stuff but invoice for the big amounts: for risk management and cash flow, stream micro‑settlements on-chain throughout the month, but roll everything up into one streamlined invoice for Coupa/Ariba to make Accounts Payable a breeze. (coupa.com)
• Opt for Layer 2s that support blob storage and have solid Account Abstraction (AA) tools. Pectra (as of May 7, 2025) has standardized EIP‑7702, enhancing smart-account user experience security. Pair this with ERC‑4337 paymasters to mask gas fees. (blog.ethereum.org)

Architecture Blueprint (High-Level)

Here's a look at the high-level architecture blueprint that lays out the key components and their relationships. This overview will help you understand the big picture.

Key Components

• Frontend: This is what the users interact with. It's all about user experience and design.
• Backend: This is where the magic happens. It handles data management, business logic, and communication between the frontend and databases.
• Database: The storage unit for all your data. It helps keep things organized and accessible.
• APIs: These are the bridges that connect different parts of the system, allowing for smooth communication between the frontend, backend, and any external services.

Relationships

1. User Interaction: Users interact with the frontend.
2. Data Flow: The frontend communicates with the backend through APIs.
3. Data Management: The backend processes requests and communicates with the database to retrieve or update data.
4. External Services: The backend can also connect with third-party services via APIs for additional functionality.

Diagram

Here’s a simplified diagram to visualize the relationships between these components:

[Frontend] <--> [Backend] <--> [Database]
                |
                +--> [External APIs]

Summary

This high-level blueprint gives you a solid understanding of how everything connects. Knowing this can help you better design and implement your system. Feel free to dive deeper into each component based on what you need!

• Ingest and Normalize
  • First up, we’re grabbing usage data in nearly real-time using Kafka. From there, our stream processors will figure out those “billable units/sec.”
  • Next, we post this info to Stripe Meters where we can set up thresholds and manage credit grants. Don't forget to make those customer dashboards visible! Check out the details here: (docs.stripe.com).
• Price and Bill
  • We’ve got Stripe Pricing Plans (still in private preview) for creating those composite enterprise rate cards that include base charges, usage, and any credits.
  • If we hit any thresholds, we can auto-invoice mid-cycle. If not, we’ll just handle the billing at the end of the month. Learn more here: (docs.stripe.com).
• Settle and Attest
  • We’ll be opening a programmatic wallet for each customer, which is essentially an AA smart account, complete with a sponsor-gas paymaster. We’ll stream USDC every second to our revenue escrow and release the net amount to your treasury on a daily basis.
  • On top of that, we can zk-attest usage batches and commit the digest on-chain every N minutes if you’d like. More info can be found here: (eips.ethereum.org).
• Post to ERP and Procurement
  • Finally, we’ll send invoices over to Coupa or Ariba, making sure to map POs and lines correctly. We’ll also attach the usage digest and payment hash for good measure during audits. Check it out here: (coupa.com).

Proof: GTM metrics to expect (and how to measure them)

• Adoption: Did you know that 77% of the biggest software companies are already on the usage-based pricing train? This means you won’t need to spend too much time educating the market--you're just jumping in where things are already happening. Keep an eye on your conversion rates for “usage-trial → paid” and watch for any decreases in discount depth on deals that go for consumption. Check out more at metronome.com.
• Net dollar retention (NDR): When you align your pricing with usage, you usually see a nice bump in expansion as long as the value grows with use. Track your NDR for different cohorts based on pricing models before and after you launch. According to Metronome, there’s been an impressive 8× YoY increase in usage-based pricing billings for 2024; aim for expansion within 2-3 quarters as your benchmark. More info here: metronome.com.
• Gross margin stability: It’s a good idea to check your L2 blob fees and cloud CUD utilization linked to product margins each week. After EIP-4844, L2 data costs plummeted, allowing for micro-settlement without being buried in fees. Your key performance indicator (KPI) should be keeping “settlement overhead per $ revenue” under 0.8%. Dive deeper at blocknative.com.
• DSO and dispute rate: By adopting streaming alongside cryptographic receipts, you should see a drop in disputes and a lower Days Sales Outstanding (DSO). Your goal should be to reduce DSO by 20-30% within two quarters among the segments that embrace streaming and credit burndown.
• Forecast accuracy: Your finance team should aim to stay within ±5-8% of monthly revenue once everything stabilizes. Leverage Stripe meter summaries and procurement purchase order balances as your inputs. Get the details at docs.stripe.com.

Who this is for--and the keywords you care about

CFO / RevOps (AI‑first SaaS, $20M-$500M ARR)

• Keywords: variable consideration, invoice practical expedient, ARR/NDR, credit burndown, commits and true‑ups, prepaid drawdown, revenue leakage, DSO. (dart.deloitte.com)

FinOps leads / Cloud economics

• Keywords: spend‑based CUDs (GCP 2026 migration), showback/chargeback, BigQuery export schema changes, unit economics by CPU‑ms/token/second. (cloud.google.com)

Platform & Billing Engineering

• Keywords: Stripe Meters, graduated rate cards, mid‑cycle price changes, AA paymasters, ERC‑1620 streaming, EIP‑7702, blob gas (type‑3 tx), CPU‑ms caps. (docs.stripe.com)

Procurement / AP Automation

• Keywords: PO matching tolerances, Coupa Supplier Actionable Notifications, SAP Ariba document‑meter pricing, touchless AP, tax codes. (coupa.com)

How 7Block Labs Engages (and What You Can Expect in 30-60 Days)

• Pricing-grade metering design: We’ll help you map out your technical units into billable meters, plus create the event taxonomy, sampling policy, and loss-tolerant aggregation you need.
• Billing enablement: Our team will set up Stripe Meters, rate cards, and thresholds. We’ll also configure credit programs and hybrid “base + usage” plans to keep things flexible. (docs.stripe.com)
• Onchain settlement rails: We’ll get smart-account wallets up and running with sponsored gas, deploy streaming contracts on a blob-enabled L2, and make sure those settlement receipts are integrated back into your ERP. (blog.ethereum.org)
• RevRec and Procurement alignment: We’ll work on your allocation rules, disclosure notes, and invoice templates so that your AP systems can hit the ground running on day one. (kpmg.com)
• Security and auditability: Count on us for code reviews and threat modeling for payment flows and settlement contracts through our security audit services.

Where to Start with Us (Choose One)

• Prototype second-based billing in a sandbox: We’ll set up meters, whip up a sample rate card, and create a streaming settlement loop on Base/OP within two weeks. All of this is backed by our web3 development services and smart contract development.
• Integrate into your enterprise stack: Let’s get Stripe linked up with Coupa/Ariba, map those PO lines to usage, and roll out AA wallets with paymasters. We’ll handle this through our blockchain integration and cross-chain solutions development.
• Plan for scale and compliance: We’ll analyze L2 costs after EIP-4844, pick the right rollups, and secure streams with ZK-attestations using our custom blockchain development services and DeFi development solutions. If you want more info on EIP-4844, check out this guide on blocknative.com.

A brief, in‑depth technical note: streaming by the second (Solidity sketch)

Alright, let’s dive into a quick yet detailed look at the concept of streaming by the second using Solidity. This will give you a solid grasp of how it works and how you can implement it.

What is Streaming by the Second?

Streaming by the second is all about processing data in real-time. Instead of waiting for a batch of information to arrive before taking action, this approach allows you to handle data as it comes in. It’s super handy for applications needing constant updates, like video streaming or live data feeds.

How Does it Work in Solidity?

In Solidity, you can create smart contracts that interact with streams of data. Here’s a basic outline of how you can set it up:

Setting Up Your Contract

Start with a simple contract structure. Here’s a basic sketch to get you going:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Streaming {
    event DataReceived(uint256 indexed timestamp, string data);
    
    function sendData(string memory data) public {
        emit DataReceived(block.timestamp, data);
    }
    
    function getData() public view returns (uint256, string memory) {
        // This would typically involve more complex logic,
        // like retrieving data from an array
        return (block.timestamp, "This is a placeholder");
    }
}

Key Components

1. Events: We use events to log incoming data. In the example above, DataReceived captures the timestamp and the data string.
2. Function to Send Data: The sendData function takes in a string and emits the event with the current timestamp.
3. Function to Get Data: The getData function is a placeholder that shows how you might return data. This method would usually involve pulling from a list or state variable.

Benefits of Streaming in Solidity

• Real-Time Updates: You get instant feedback on actions, making your application feel more responsive.
• Efficiency: Instead of processing large batches, you can handle smaller chunks of data, which can be more efficient and less resource-intensive.
• Enhanced User Experience: Users appreciate real-time updates, so this can greatly enhance their interaction with your app.

Conclusion

Streaming by the second in Solidity is a powerful tool for creating real-time applications. By using events and smart contracts, you can efficiently handle data as it arrives, making your app snappier and more interactive.

Feel free to experiment and expand on this basic sketch. Happy coding!

Learn more about Solidity

// Minimal ERC-1620-style stream with second granularity (illustrative)
struct Stream {
  address sender;
  address recipient;
  address token;
  uint128 ratePerSecond;   // tokens per second, scaled
  uint64  start;
  uint64  stop;
  uint256 balance;         // remaining deposit
  uint256 lastWithdraw;    // last withdrawal timestamp
}

function available(uint256 id) public view returns (uint256) {
  Stream storage s = streams[id];
  uint64 t = uint64(block.timestamp);
  if (t <= s.start) return 0;
  uint64 elapsed = t < s.stop ? (t - s.start) : (s.stop - s.start);
  uint256 earned = uint256(elapsed) * s.ratePerSecond;
  uint256 withdrawn = uint256(uint64(s.lastWithdraw - s.start)) * s.ratePerSecond;
  return earned > withdrawn ? min(earned - withdrawn, s.balance) : 0;
}

• Place this on a blob-cheap L2 (post-4844) and pair it with an ERC-4337 paymaster so customers can avoid dealing with gas fees. For a smoother enterprise experience, integrate it with a “credit burndown” ledger in Stripe. This way, you can settle risks throughout the month and have invoices that summarize everything at the end of the month for accounts payable. (blocknative.com)

If you’re still on the fence about this:

• Second-granularity isn’t some far-fetched idea. Your suppliers already charge by the sub-second (think Cloud Run vCPU-seconds or Workers CPU-ms). Stripe Meters makes it easy to track usage, set thresholds, and even get previews. Plus, Ethereum’s upcoming 2025 Pectra upgrade is set to make smart-account UX the norm, while 4844 helps keep L2 settlement affordable for those micro-transactions. The landscape is changing fast! Check it out here: (cloud.google.com).

Personalized CTA

Hey there! If you’re the VP of Finance or Head of RevOps at an AI SaaS company with between 200 and 1,500 employees, and you’re already using Stripe along with Coupa or SAP Ariba for accounts payable, we’ve got something you might find super useful. If you're aiming to get one SKU live with second-based pricing by April 30, 2026--and you need it to be ASC-606-ready with recognition, PO-matched invoices, and gas-sponsored on-chain settlement--then let’s chat!

Book a quick 30-minute “Meters-to-Settlement” working session with us. During this time, we'll work together to map your top two value meters to Stripe. Plus, we'll design an EIP-7702/4337 autopay flow on a blob-enabled L2 and provide you with a tailored two-week implementation plan that includes ROI calculations specific to your setup.

Once we’ve got the plan, we'll roll up our sleeves and build it out alongside you with our blockchain integration and web3 development services. This way, you can showcase NDR lift and cleaner RevRec in Q2!