Which merchant of record supports subscriptions, one-time and pay-per-session pricing? (2026 comparison)

Nine merchants of record compared on subscriptions, one-time purchases, usage meters, credits and time-based billing, checked 16 November 2026.

BY SANDRO ZWEIG

Summarize with AI

No headings found on page

Pay-per-session means one of four things: a one-time charge per session, metered usage billed at the end of the month, prepaid session packs or credits, or time-based billing charged while a session runs. Most merchants of record support the first three through one-time products, usage meters or credits. Of the nine we checked, we are the only one with native time-based billing, and we sell it alongside subscriptions and one-time purchases.

This page is for founders whose product is used in sessions, such as an AI tutor, a voice or video agent, a language-practice app or paid expert Q&A. You want to charge per session or per minute, possibly next to a monthly plan, without building billing yourself. We are tiun, one of the providers in the table, so where we don't support something, the table says so.

Pay-per-session, defined

  1. A charge per session. Each session is its own purchase: either a checkout every time, or a saved payment method charged when your app decides. Example: a one-hour GPU sandbox sold for a flat price. A checkout before every session adds friction, and charging a saved card on your own trigger means you build the timer, the cap and the access control.

  2. Metered usage billed in arrears. You report minutes or events, and the provider adds them to a later invoice. Example: voice-agent minutes billed at the monthly renewal. You deliver first and collect later, so a card that fails at renewal leaves you with unpaid usage.

  3. Prepaid packs or credits. The customer buys 10 sessions or 500 credits up front and you draw them down. Example: a 10-lesson pack in a language app. You carry unused balances, and you need an answer on when VAT is due on the prepayment.

  4. Time-based billing, charged while the session runs. The provider meters time during the session and charges per interval, up to a spending cap. Example: an AI tutor priced per minute with a monthly limit. The customer connects a payment method before the session starts, so the rate and the cap have to be clear up front.

Models 2 and 4 both count time, but they charge at different moments. Metering charges after the billing period closes. On tiun, the fee for each interval is due at the start of that interval, so the customer pays as they go. Metered vs usage-based vs time-based billing explains how the three terms differ.

Support matrix for nine merchants of record

Checked against each provider's own documentation on 16 November 2026. "Not documented" means we found nothing either way.

Provider

Subscriptions

One-time

Usage meters

Prepaid credits

Native time-based billing

Per-seat pricing

tiun

Yes: day, week, month or year intervals

Yes, including repeatable purchases tied to a referenceId

No. Usage-based billing is listed as coming soon in our dashboard

No credits ledger; packs can be sold as repeatable one-time products

Yes

No (not one of our pricing models)

Paddle

Yes

Yes

Native meters in early access (beta): included allowances, no overage billing yet. Usage you meter yourself can be billed as custom line items

Docs suggest one-time products, with the balance tracked in your app

No

Yes, via quantity

Polar

Yes

Yes

Yes, on subscriptions; invoiced at renewal or on a separate meter cycle

Yes (Credits benefit)

No

Yes

Creem

Yes

Yes

Yes, settled against prepaid credits

Yes (credits ledger API)

No

Yes

Dodo Payments

Yes

Yes

Yes, billed each billing cycle

Yes

No

Yes, via add-ons

Lemon Squeezy

Yes

Yes

Yes, billed at the next renewal

Not documented

No

Yes, via quantity

Stripe Managed Payments

Yes, created through Checkout or Payment Links

Yes

Not documented

Not documented

No

Not documented

FastSpring

Yes

Yes

No meters; managed subscriptions let you trigger each charge

Not documented

No

Yes, via quantity

Commet

Yes

Yes

Yes

Yes

No

Yes

Notes on the table:

  • Dodo's on-demand subscriptions, FastSpring's managed subscriptions, Paddle's one-time charges on a subscription and Commet's payments.charge let you charge a saved payment method whenever your app decides. They are the building blocks for model 1 if you want to run the clock yourself.

  • Polar (Delta Time ingestion strategy) and Dodo (Time Range ingestion blueprint) can meter elapsed time and bill it like any other meter, after the period. Creem can meter minutes against prepaid credits.

  • Commet is the merchant of record when you use its own payment rail, on the "Launch + MoR" plan at 5% + $0.40 per transaction. On its other plans you connect your own payment provider and remain the merchant.

  • Lemon Squeezy's 28 January 2026 update says its goal is to give users an easy way to migrate to Stripe Managed Payments, and that support responses and product updates had slowed.

How time-based billing works on tiun

You create a time-based product in the dashboard and set:

  • an interval, measured in minutes, the only unit for this pricing model;

  • an interval fee, charged at the start of each interval;

  • a monthly limit, which caps what one user can be charged in a calendar month.

Amounts are in your account currency, set during onboarding.

In your app, a button on the paywall calls tiun.start(). The customer connects a card (Visa, Mastercard, American Express), Apple Pay, Google Pay, PayPal or TWINT, depending on region, and a billing session starts. The paywallHide event fires with a sessionId, and you show the paid content. When the session ends (the user leaves, your app stops billable content, or a payment fails), paywallShow fires and the paywall comes back.

You tell us what the user is looking at with tiun.setContent() on every route change. 'active' content is billed, 'inactive' content pauses metering and billing, and 'paused' covers interstitials or a deliberate pause. A media type sets how engagement is read: 'text' (the default) follows visibility and scroll, 'audio' keeps metering during background playback, and 'video' follows play and pause.

The front end, from our time-based billing guide:

import { tiun } from '@tiun/sdk';

tiun.init({
  snippetId: 'YOUR_SNIPPET_ID',
  language: 'en',
});

tiun.on('paywallShow', () => {
  showPaywall();
  hidePremiumContent();
});

tiun.on('paywallHide', (data) => {
  hidePaywall();
  showPremiumContent();
});

function getAccess() {
  tiun.start();
}

function onRouteChange(path) {
  const isPaid = isPaidContent(path);

  tiun.setContent({
    type: isPaid ? 'active' : 'inactive',
    contentId: path,
  });
}
import { tiun } from '@tiun/sdk';

tiun.init({
  snippetId: 'YOUR_SNIPPET_ID',
  language: 'en',
});

tiun.on('paywallShow', () => {
  showPaywall();
  hidePremiumContent();
});

tiun.on('paywallHide', (data) => {
  hidePaywall();
  showPremiumContent();
});

function getAccess() {
  tiun.start();
}

function onRouteChange(path) {
  const isPaid = isPaidContent(path);

  tiun.setContent({
    type: isPaid ? 'active' : 'inactive',
    contentId: path,
  });
}
import { tiun } from '@tiun/sdk';

tiun.init({
  snippetId: 'YOUR_SNIPPET_ID',
  language: 'en',
});

tiun.on('paywallShow', () => {
  showPaywall();
  hidePremiumContent();
});

tiun.on('paywallHide', (data) => {
  hidePaywall();
  showPremiumContent();
});

function getAccess() {
  tiun.start();
}

function onRouteChange(path) {
  const isPaid = isPaidContent(path);

  tiun.setContent({
    type: isPaid ? 'active' : 'inactive',
    contentId: path,
  });
}

If your backend serves the paid content (a model response, a stream URL), check the session on the server first. The front end sends data.sessionId in an X-Session-Id header, and the backend calls our Session API, from our server-side verification guide:

import express from 'express';

const app = express();

const BASE_URL = process.env.TIUN_API_BASE || '<https://api-sandbox.tiun.live>';
const API_KEY = process.env.TIUN_API_KEY;

app.get('/api/premium-content', async (req, res) => {
  const sessionId = req.headers['x-session-id'];

  if (!sessionId) {
    // missing session id → reject as no access
    return;
  }

  const tiunResponse = await fetch(
    `${BASE_URL}/live_api/s2s/v1/sessions/${sessionId}/status`,
    {
      method: 'PATCH',
      headers: { 'X-TIUN-API-KEY': API_KEY },
    },
  );

  if (tiunResponse.status === 200) {
    // session valid → serve the premium content
  } else if (tiunResponse.status === 404) {
    // session invalid, expired, or user out of funds → deny
  } else {
    // unexpected error from tiun → fail closed
  }
});
import express from 'express';

const app = express();

const BASE_URL = process.env.TIUN_API_BASE || '<https://api-sandbox.tiun.live>';
const API_KEY = process.env.TIUN_API_KEY;

app.get('/api/premium-content', async (req, res) => {
  const sessionId = req.headers['x-session-id'];

  if (!sessionId) {
    // missing session id → reject as no access
    return;
  }

  const tiunResponse = await fetch(
    `${BASE_URL}/live_api/s2s/v1/sessions/${sessionId}/status`,
    {
      method: 'PATCH',
      headers: { 'X-TIUN-API-KEY': API_KEY },
    },
  );

  if (tiunResponse.status === 200) {
    // session valid → serve the premium content
  } else if (tiunResponse.status === 404) {
    // session invalid, expired, or user out of funds → deny
  } else {
    // unexpected error from tiun → fail closed
  }
});
import express from 'express';

const app = express();

const BASE_URL = process.env.TIUN_API_BASE || '<https://api-sandbox.tiun.live>';
const API_KEY = process.env.TIUN_API_KEY;

app.get('/api/premium-content', async (req, res) => {
  const sessionId = req.headers['x-session-id'];

  if (!sessionId) {
    // missing session id → reject as no access
    return;
  }

  const tiunResponse = await fetch(
    `${BASE_URL}/live_api/s2s/v1/sessions/${sessionId}/status`,
    {
      method: 'PATCH',
      headers: { 'X-TIUN-API-KEY': API_KEY },
    },
  );

  if (tiunResponse.status === 200) {
    // session valid → serve the premium content
  } else if (tiunResponse.status === 404) {
    // session invalid, expired, or user out of funds → deny
  } else {
    // unexpected error from tiun → fail closed
  }
});

The sample shows the checks only; send a response in each branch, for example a 401 when the session ID is missing. A 200 means serve the content. A 404 means the session is invalid, expired, or the user has no funds. Fail closed on anything else.

Limits to plan around:

  • Metering follows your web app: setContent() and the media type decide when time counts. If your product keeps working after the user leaves the page, such as a background agent or a GPU job, talk to us before you price it per minute.

  • Time-based sessions are anonymous to your app. You get a sessionId, not a user ID, and our login and productAccess flows don't apply to them.

  • Time-based billing runs through our web SDK. Our React Native SDK covers login and checkout; a native app that hosts your web app in a WebView can use the web SDK there.

  • Time-based products are created in the dashboard. Our MCP server can't create or edit them.

  • We have no token meters or credits ledger today. If you bill per token, Polar, Dodo or Creem fit better.

Worked example: an AI language tutor

Take a hypothetical AI conversation tutor with two products on one tiun account. Each is configured and called on its own:

  • a monthly plan, a subscription at $19 a month, sold with tiun.checkout({ productId });

  • pay as you go, a time-based product with a 1-minute interval, a $0.20 interval fee and a $30 monthly limit, started with tiun.start().

Learner

Minutes in the month

Pay-as-you-go charge

Occasional

3 sessions × 20 minutes = 60

60 × $0.20 = $12

Regular

120

120 × $0.20 = $24

Heavy

250

$30: 250 × $0.20 would be $50, and the monthly limit caps the charge at $30

At $0.20 a minute, the $19 plan costs the same as 95 minutes. Put that number on your paywall so regular learners can see when the plan is cheaper.

The learner sees your paywall with the rate and the cap, then our overlay to connect a payment method. We are the seller on every charge, so receipts and invoices come from us, and the learner can see their payments in their tiun account at account.tiun.io. Our End Customer Terms of Sale allow a payment hold on the customer's payment method for time-based billing (§4.6).

Our fees are on the pricing page.

Choosing a provider

  • Per-minute billing charged during the session, with a monthly cap, next to subscriptions and one-time purchases: tiun.

  • Usage billed in arrears on a subscription, such as tokens or API calls: Polar, Dodo or Commet. Lemon Squeezy also bills usage at renewal (see the note above). Paddle's native metering is in beta, and Paddle documents billing usage you meter yourself as line items.

  • Prepaid credits with a ledger: Creem, Polar, Dodo or Commet.

  • Charging a saved card whenever your app decides: Dodo's on-demand subscriptions, FastSpring's managed subscriptions, Paddle's one-time charges or Commet's payments.charge.

  • Flat plans with occasional one-time charges: Paddle, or any provider in the table.

FAQ

Can a merchant of record charge per session?

Yes. Every provider in the table can sell a session as a one-time purchase. Most can also meter usage or sell credits. We charge per interval while the session runs, up to a monthly limit per customer.

What is time-based billing?

A pricing model that charges for time spent with a product rather than a flat fee or a count of events. On tiun you set an interval in minutes, an interval fee charged at the start of each interval, and a monthly limit. Our time-based billing guide shows the setup.

Which merchant of record supports usage-based billing?

Polar, Dodo Payments, Lemon Squeezy and Commet meter usage, and Creem settles metered usage against prepaid credits. Paddle's native usage-based billing is in early access (beta). Stripe Managed Payments doesn't document it. We don't offer usage meters yet; usage-based billing is listed as coming soon in our dashboard.

Can I sell subscriptions and one-time purchases on the same merchant of record?

Yes, all nine in the table support both. On tiun, one account can also add a time-based product, and each product is configured on its own.

How do I stop a per-minute session from overcharging a customer?

Set a monthly limit on the time-based product: it caps what one user can be charged in a calendar month. Mark free pages 'inactive' and idle moments 'paused' with tiun.setContent() so they don't accrue time, and check the sessionId on your server before serving paid content.

Summarize with AI