# Leverprice vs 1Price: server-side bandit vs client-side split

Source: https://leverprice.com/compare/leverprice-vs-1price
Updated: 2026-11-17

> Pick 1Price if you sell Stripe subscriptions, want MRR and realized lifetime value per visitor, and are fine with a browser script splitting traffic evenly between two offers. Pick Leverprice if you want prices set on your server, traffic moved toward the best of several prices automatically, and revenue verified from Stripe, Polar, Lemon Squeezy or Dodo Payments.

Leverprice and 1Price answer the same question, which price earns more, from opposite ends of the request. 1Price runs a script in the visitor's browser and splits a share of new visitors evenly between two offers ([docs](https://docs.1price.co/build/firstExp.md)). Leverprice computes the price on your server and, on its Pro plan, lets a bandit move traffic toward the price with the highest revenue per visitor.

Leverprice is our product. Where 1Price is the better fit, this page says so, and if neither fits, there are five more options in [1Price alternatives](https://leverprice.com/alternatives/1price). Every 1Price fact below was checked against its own docs and pricing page on November 17, 2026.

## How do Leverprice and 1Price compare?

| | Leverprice | 1Price |
|---|---|---|
| Approach | Server-side SDK plus a Thompson-sampling bandit | Browser script plus an API that returns Stripe price IDs |
| Where prices are decided | On your server; every price is checked against your own min and max | In the browser: your page asks 1Price's API and gets a `stripe_price_id`; server-side setup is a beta the docs advise against ([docs](https://docs.1price.co/build/code.md)) |
| Prices per test | Several prices from a range you set | A control offer and one treatment offer; each offer can hold several products with monthly and yearly prices |
| Automatic optimization | Yes on Pro: traffic moves toward the highest revenue per visitor; Free is a manual split | No adaptive allocation documented: the audience share you set is split evenly |
| Assignment | Signed first-party cookie; a user ID gives the same bucket on every device | Random, new customers only |
| How a winner is called | One price at least 95% likely to be best, or the rest practically equivalent (expected relative loss under 0.5%) | Not described in the results docs ([results](https://docs.1price.co/build/results.md)) |
| Revenue source | Signed webhooks from your provider; refunds subtract. On Stripe, verification covers one-time Checkout Sessions; a subscription's first payment is reported with `trackPurchase()`, shows as unverified and counts when the Learn from setting is Reported | Stripe Checkout Sessions tagged with `oneprice_cid`; subscription creation tracking in beta |
| Reports | Revenue per visitor for each price, with revenue, sales or profit as the goal | Visitors, paid conversion, MRR, active and churned subscribers, realized LTV per visitor, for new users |
| Prices by country | [Regional prices](https://leverprice.com/blog/regional-pricing): set by hand per country or from five country tiers by World Bank price level, in the local currency; in a test, each visitor keeps one variant at that variant's price for their country, with results by region | Homepage lists localized pricing and automatic local currency adjustment ([1Price](https://1price.co/)) |
| Payment providers | Stripe, Polar, Lemon Squeezy, Dodo Payments | Stripe; other integrations marked "soon" on its homepage |
| SDK languages | TypeScript/JavaScript, Python, PHP, Ruby, Go | Browser script; JavaScript examples only, and your backend creates the Checkout Session in any language |
| Pricing (Nov 2026) | Free; Pro $29/month or $199/year; Lifetime $299 once ([pricing](https://leverprice.com/pricing)) | From $39/month for up to 5k monthly traffic, rising with traffic; 25% off yearly; 7-day free trial ([pricing](https://1price.co/pricing)) |

## Where does each tool decide the price?

1Price decides it in the browser. A script in your `<head>` creates a `$1Price` object, your page sends it to 1Price's `price_value` endpoint, and the response lists your products with monthly and yearly prices, formatted prices and a `stripe_price_id` ([docs](https://docs.1price.co/build/code.md)). Your backend then creates the Stripe Checkout Session for that price ID with `oneprice_cid` in the metadata. When the API call fails, the response comes back with `success: false`, so your page needs a price of its own for that case. If the price ID reaches your backend from the page, the backend should accept only the price IDs in the running test.

Leverprice decides it on your server, where you render the pricing page and again where you create the checkout. The SDK reads a signed config (an offline root key signs a keyset, which signs the config), checks every price against your own minimum, maximum and currency, and returns your fallback price if no valid config arrives within 500 ms. Crawlers, link previews and monitors get the standard price and are never enrolled, and prefetch requests are priced but not counted. No Leverprice JavaScript runs in the browser. [Server-side price testing](https://leverprice.com/blog/server-side-price-testing) explains why that matters for tampering and SEO.

*Figure: Flow from a visitor's request to your server asking Leverprice for a price, then the checkout, then traffic moving toward the better price. Leverprice prices the page and the checkout on your server; purchases come back through signed webhooks and move traffic.*

The trade-off is setup. 1Price's script drops into an existing page, and your backend changes only where it creates the Checkout Session. Leverprice asks for a server call in two places, which is a few lines in a framework you already run.

## Does a bandit beat an even split for pricing?

For revenue during the test, usually yes. With two offers at an even split, half of the test traffic sees the weaker price until you stop. A bandit shifts visitors toward the leader as evidence builds, so the test costs less while it runs.

Example: 4,000 visitors a month enter the test. The better price earns $1.00 per visitor and the weaker one $0.85. An even split sends 2,000 visitors to the weaker price and gives up 2,000 × ($1.00 - $0.85) = $300 that month. If a bandit has moved 80% of traffic to the leader, the same month costs 800 × $0.15 = $120.

A fixed split has its own strengths. Equal samples give each price the same precision, and the math is easy to audit. GrowthBook's docs note that with only two arms a standard experiment may do better than a bandit ([GrowthBook docs](https://docs.growthbook.io/bandits/overview)). The bandit's edge grows with the number of prices, and Leverprice tests a range of them. More in [bandit vs A/B testing for pricing](https://leverprice.com/blog/bandit-vs-ab-test-pricing).

*Figure: Two stacked area charts of traffic share for three prices over 40 days: the even split keeps a third of visitors on each price, while Leverprice moves most of them to the leading price. Our simulation of the production engine at 300 sales a month with prices of $19, $29 and $49. By day 40 the bandit sends about 89% of visitors to the leader.*

## How does each tool measure revenue?

Both read revenue from Stripe instead of trusting a browser event. 1Price tags each Checkout Session with `oneprice_cid` and tracks Checkout Sessions; tracking of subscription creation is in beta ([docs](https://docs.1price.co/build/code.md)). Its reports lean toward subscriptions: MRR, active and churned subscribers, and realized LTV per visitor and per paying customer, for new users only ([results](https://docs.1price.co/build/results.md)).

Leverprice verifies each paid order with your provider's signed webhook. You give it the webhook signing secret, which can confirm events but can't move money, and your server creates the checkout with your own keys, so Leverprice never sees card data or provider API keys. Refunds reduce the revenue of the price that earned them, test and live mode stay separate, and a purchase in another currency is converted back to the experiment currency. Only visitors older than 30 minutes count, so fresh traffic doesn't drag a price down before its buyers have had time to pay. The ranking metric is [revenue per visitor](https://leverprice.com/glossary/revenue-per-visitor).

Subscriptions depend on the provider. On Stripe, Leverprice's webhook verification covers one-time Checkout Sessions; a subscription's first payment is reported from your server with `trackPurchase()` and shows as unverified, and the engine learns from it only when the project's Learn from setting is Reported. Polar verifies a subscription's first payment, and Dodo Payments verifies one-time payments only. If you sell Stripe subscriptions, that's a point for 1Price.

Leverprice also doesn't report MRR, churn or lifetime value. A price that converts well but churns fast will look better in Leverprice than it will a year later, and 1Price's realized-LTV view is the better lens for that question.

## Choose 1Price if

- You sell subscriptions through Stripe Checkout and want MRR, churn and realized LTV per visitor in the report.
- You want to test whole offers, several plans with monthly and yearly prices, in one experiment.
- You'd rather paste a script than add server calls, and two offers per test is enough.
- You like a money-back guarantee and prices fixed for 12 months ([pricing](https://1price.co/pricing)).

## Choose Leverprice if

- You take payments through Polar, Lemon Squeezy or Dodo Payments, or through Stripe and want to keep other providers open.
- You want several prices in one test and traffic that shifts toward the leader without you.
- You want the price computed on your server, checked against your own bounds, with a fallback when anything fails and crawlers kept out.
- Your backend runs TypeScript, Python, PHP, Ruby or Go.
- You want prices per country in the local currency and test results you can read by region.
- You want to start free, or pay a flat $29/month or $199/year on Pro instead of a traffic-banded price.
- You'd like a coding agent to set up tests and read results through Leverprice's MCP server or CLI.

## How do you move from 1Price to Leverprice?

1. Stop the running 1Price experiment. Customers it enrolled get your default offering the next time they reach the paywall ([docs](https://docs.1price.co/build/firstExp.md)).
2. Remove the 1Price script and the `price_value` request from your pages, so only one tool assigns prices.
3. Install the SDK and define the product with a fallback price and the minimum and maximum you'd ever charge.
4. Call `getPrice()` where you render the pricing page and again where you create the checkout. Replace the `stripe_price_id` from 1Price with `price_data` built from the quote, and pass `quote.metadata` whole where `oneprice_cid` used to go.
5. Connect your Stripe webhook signing secret in Leverprice (the [Stripe integration](https://leverprice.com/integrations/stripe) page lists the events) and start a test on new visitors.

```ts title="app/api/checkout/route.ts"
import Stripe from "stripe";
import { leverprice } from "@/lib/leverprice";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(request: Request) {
  // Price the checkout on the server; never trust a price sent by the browser.
  const quote = await leverprice.getPrice("pro", { request });

  const session = await stripe.checkout.sessions.create({
    mode: "payment",
    line_items: [{
      quantity: 1,
      price_data: { currency: quote.currency, unit_amount: quote.price, product_data: { name: "Pro" } },
    }],
    metadata: quote.metadata, // signed attribution, passed whole (replaces oneprice_cid)
    payment_intent_data: { metadata: quote.metadata },
    success_url: "https://example.com/thanks",
    cancel_url: "https://example.com/pricing",
  });

  const res = Response.json({ url: session.url });
  for (const cookie of quote.setCookie) res.headers.append("Set-Cookie", cookie);
  return res;
}
```

The snippet charges a one-time payment, the case Leverprice's Stripe webhook verification covers. If your 1Price setup creates subscriptions, report each subscription's first payment from your webhook handler with `trackPurchase()` and set the project's Learn from setting to Reported; Leverprice shows that revenue as unverified. The [docs](https://leverprice.com/docs) show both calls. Don't run both tools on the same pricing page at once: two tools assigning prices to one visitor ruin both results.

## Frequently asked questions

### Is 1Price server-side?

Its standard setup is a browser script that asks 1Price's API for prices. A server-side implementation exists as a beta, and 1Price's docs strongly advise against it.

### Does 1Price use a multi-armed bandit?

Its docs describe an even split between a control and one treatment offer, with no adaptive allocation documented. Its homepage talks about automating experiments, but the setup docs describe a fixed split.

### Can Leverprice show MRR or churn like 1Price?

No. Leverprice scores each price on verified paid orders minus refunds and reports revenue per visitor; it doesn't report MRR, churn or lifetime value.

### Does Leverprice verify Stripe subscription payments?

Its Stripe webhook verification covers one-time Checkout Sessions. A Stripe subscription's first payment is reported from your server with `trackPurchase()`, shows as unverified and counts only with the project's Learn from setting on Reported; on Polar, a subscription's first payment is verified by webhook.

### Which one costs less?

At up to 5k monthly traffic, 1Price starts at $39/month, 25% less billed yearly, and the price rises with traffic. Leverprice Pro is $29/month or $199/year with unlimited tested revenue, and Free runs a manual split on one product up to $500/month of tested revenue.

### Do I need a backend for either tool?

1Price needs one to create the Stripe Checkout Session. Leverprice's SDK runs on your server, and sites without a backend can use its no-code checkout links, though the page then can't display the tested price.
