Leverprice vs GrowthBook for price testing

GrowthBook price testing means flags, your own price code and warehouse metrics, with bandits on Pro. How it compares with Leverprice, and when to use both.

Short answer

GrowthBook can test prices if you write the price code and build revenue metrics from your warehouse; its Pro plan adds Thompson-sampling bandits. Leverprice does only prices: server SDKs that return a bounded price, a bandit on revenue per visitor and revenue from signed provider webhooks. Use GrowthBook for flags and product tests, Leverprice for prices.

  • GrowthBook bandits use Thompson sampling, keep at least 1% of traffic on every variation, and come with the Pro and Enterprise plans.
  • GrowthBook metrics are SQL queries on your own data; we found no native Stripe connector, so revenue per variation starts with a warehouse pipeline.
  • GrowthBook's docs warn that a bandit without sticky bucketing moves users between variations, which for prices means one visitor can see two prices.
  • Leverprice keeps each visitor's price with a signed first-party cookie and reads revenue from Stripe, Polar, Lemon Squeezy or Dodo Payments webhooks.

GrowthBook is open source, queries your own warehouse and, on its Pro plan, runs Thompson-sampling bandits (docs). If your team already ships features behind GrowthBook flags, a price test looks like one more experiment. The price itself is left to you: your code maps a variation to an amount and charges it at checkout, and revenue per variation exists only once Stripe data reaches the warehouse GrowthBook queries.

Leverprice is built for exactly that part: the price, its attribution through checkout and the revenue that comes back. Leverprice is our product; this page says where GrowthBook is the better choice and how to run both. GrowthBook facts were checked against its docs and pricing page on November 17, 2026.

How do Leverprice and GrowthBook compare for price testing?

LeverpriceGrowthBook
ApproachPurpose-built price testingOpen-source feature flags and warehouse-native experiments
Where prices are decidedOn your server: the SDK returns a price checked against your own min and maxIn your code: the SDK returns a variation, and you map it to a price
Automatic optimizationYes on Pro: Thompson sampling on revenue per visitor, weights recomputed every 5 minutes, at least 5% per priceYes on Pro and Enterprise: Thompson sampling, at least 1% per variation, Bayesian engine only (docs)
Sticky assignmentSigned first-party cookie; a user ID gives the same bucket on every deviceSticky bucketing; without it, a bandit moves users between variations
Revenue sourceSigned provider webhooks, matched through signed checkout metadata; refunds subtract. On Stripe, one-time Checkout Sessions are verified; a subscription's first payment is reported with trackPurchase(), shows as unverified and counts when the Learn from setting is ReportedSQL metrics on your warehouse; no native Stripe connector found
Payment providersStripe, Polar, Lemon Squeezy, Dodo PaymentsAny whose data reaches your warehouse
SDK languagesServer only: TypeScript/JavaScript, Python, PHP, Ruby, GoJavaScript, React, Vue, Node.js, PHP, Ruby, Python, Java, C#, Go, Elixir, Rust, Kotlin, Swift, Flutter, React Native, plus edge SDKs (SDKs)
HostingHosted; the SDKs are open sourceCloud, or self-hosted open source
Pricing (Nov 2026)Free; Pro $29/month or $199/year; Lifetime $299 once (pricing)Starter free for 3 users; Pro $40 per seat per month, with bandits; self-hosted open source (pricing)

How do you run a price test in GrowthBook?

In GrowthBook, a price test is an experiment whose variations your code maps to prices. The setup:

  1. Create an experiment with one variation per price, and turn on sticky bucketing so a visitor keeps their price.
  2. On your server, evaluate the experiment for each visitor and map the variation to an amount. Use the same amount on the pricing page and at checkout, and don't accept it from the browser.
  3. Put the variation in the checkout metadata, or in your own orders table, so every payment can be traced back to it.
  4. Get Stripe data into your warehouse and write the revenue metric as a SQL query over it.
  5. Choose the analysis: a fixed split, or on Pro a bandit with revenue as the decision metric and an update cadence that matches how long buyers take to pay.

The full walkthrough is in price testing with GrowthBook.

What do GrowthBook's docs warn about bandits?

GrowthBook's bandit docs are candid, and most of the caveats bite harder on prices than on button colors (docs):

  • Without sticky bucketing, a bandit moves users between variations over time. For a price, that means a returning visitor can see a different price.
  • With only two arms, a standard experiment may do better.
  • Bandit estimates of each variation's average can carry positive and negative biases.
  • A change that makes people convert sooner without converting more can mislead a bandit.
  • The decision metric should be measurable soon after exposure; long sales cycles favor a standard experiment.
  • Bandits run only under the Bayesian engine.

Leverprice works under the same constraints and handles some of them by design. Prices stay sticky through a signed first-party cookie, only visitors older than 30 minutes count so fresh traffic doesn't look worse, and every price keeps at least 5% of traffic. It still learns from purchases, so slow buyers slow it down too. How the engine scores prices is explained in Thompson sampling for pricing.

How long does a price test take?

Longer than most founders expect, whichever tool runs it. In 960 simulations of Leverprice's production engine, a price that earned 10% more per visitor was found in a median of 40 days at 300 sales a month, 14 days at 1,000 sales and 263 days at 50 sales (study). A classic even split sized for 95% confidence and 80% power would need 663 days for the same 300-sales case.

Those figures describe our engine and its stopping rule only. We haven't found comparable published figures for GrowthBook's bandits; its docs advise matching the update cadence to how long buyers take to convert. Whatever you run, testing prices further apart shortens the test more than any setting does: in the same simulations, a 20% better price took a median of 23 days at 300 sales a month.

Our simulation of the production engine: median days to a decision by monthly sales and price advantage.

Choose GrowthBook if

  • You already run GrowthBook and want every experiment, prices included, in one system.
  • You need open source or self-hosting for the whole stack.
  • Your payments already land in a warehouse next to your product events.
  • You sell through a provider Leverprice doesn't support, such as Paddle, Gumroad or FastSpring.
  • You want to test more than amounts: plan structure, onboarding, paywall copy.

Choose Leverprice if

  • You want the price, its checkout attribution and revenue verification handled for you, without a warehouse.
  • You want the price computed on your server with your own bounds, a fallback within 500 ms when anything fails, and crawlers kept out.
  • You want sticky prices without configuring bucketing: a signed first-party cookie, and the same bucket on every device when you pass a user ID.
  • Bandits would be your only reason to upgrade to GrowthBook Pro at $40 per seat per month, while Leverprice Pro is a flat $29 a month.
  • You want regional prices per country, in the local currency, inside the same test.
  • You take payments through Stripe, Polar, Lemon Squeezy or Dodo Payments.

How do you use GrowthBook and Leverprice together?

Keep GrowthBook for flags and product experiments, and let Leverprice own the price amount. Two rules keep the data clean:

  1. Don't put the price behind a GrowthBook feature while Leverprice tests it. One system assigns the price.
  2. Record the price each visitor saw (quote.price and quote.currency, plus quote.variantId when quote.reason is "experiment") in the event data your warehouse already collects, so analyses on either side can be cut by price.

Moving a running GrowthBook price experiment over takes four steps:

  1. Stop the GrowthBook experiment and set the feature to a single value.
  2. Replace the variation-to-price mapping with getPrice() on the server, where you render the pricing page and where you create the checkout.
  3. Pass quote.metadata whole into the checkout and connect your provider's webhook signing secret in Leverprice; the docs cover each framework.
  4. Start the Leverprice test on new visitors, and keep its numbers apart from the old experiment's.
app/api/price/route.ts
import { leverprice } from "@/lib/leverprice";

export async function GET(request: Request) {
  // Was: a GrowthBook variation that your code mapped to an amount.
  const quote = await leverprice.getPrice("pro", { request });

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

Frequently asked questions

Does GrowthBook have multi-armed bandits?

Yes, on the Pro and Enterprise plans. They use Thompson sampling, keep at least 1% of traffic on every variation and run only under the Bayesian engine (docs).

Does GrowthBook connect to Stripe?

We found no native Stripe connector. GrowthBook metrics are SQL queries on your own data, so Stripe revenue has to reach your warehouse before it can score a price.

Can I self-host Leverprice like GrowthBook?

Leverprice is a hosted service. Its SDKs are open source and run on your server, and no Leverprice JavaScript runs in the browser.

Which is cheaper for price testing?

GrowthBook Starter is free for 3 users but has no bandits, and Pro costs $40 per seat per month (pricing). Leverprice Free runs manual splits up to $500/month of tested revenue, and Pro is a flat $29/month or $199/year.

Can I run GrowthBook experiments and Leverprice tests at the same time?

Yes, on different things. Leave the price amount to Leverprice, run GrowthBook experiments on everything else, and never let both assign a price to the same visitor.