Leverprice vs Optimizely for price testing

Optimizely price testing runs inside its web and feature experiments, with bandits and quoted plans. How it compares with Leverprice for software prices.

Short answer

Optimizely fits enterprises that already run web and feature experiments and want price tests inside that program; plans are quoted individually and revenue is an event you send. Leverprice costs $29 a month and does one job: it sets prices on your server and moves traffic toward the best revenue per visitor, using revenue from signed provider webhooks.

  • Optimizely's bandits use Thompson sampling for binary metrics and epsilon-greedy for numeric ones, and bandit results carry no statistical significance.
  • In Optimizely Web Experimentation, revenue reaches Optimizely from your page through its snippet API.
  • Optimizely doesn't publish prices: every plan is packaged individually and starts with a demo request.
  • Leverprice reads revenue from signed Stripe, Polar, Lemon Squeezy or Dodo Payments webhooks and publishes its prices: Free, Pro at $29/month, Lifetime at $299.

Optimizely is built for companies that run experimentation as a program: web tests, feature flags and personalization, owned by a team. A price test fits inside that program as one more experiment, and Optimizely's bandit can move its traffic (docs). Bought only to test prices, it's a lot of platform, and its own price arrives through a sales call (plans).

Leverprice is our product and tests prices only. This page says where Optimizely is the better choice and how the two can run side by side. Optimizely facts were checked against its docs and plans page on November 17, 2026.

How do Leverprice and Optimizely compare for price testing?

LeverpriceOptimizely
ApproachPurpose-built price testingEnterprise web experimentation, feature experimentation and personalization
Where prices are decidedOn your server: the SDK returns a price checked against your own min and maxIn your page or your code: a variation or flag that you map to a price
Automatic optimizationYes on Pro: Thompson sampling on revenue per visitor, weights recomputed every 5 minutesYes: bandits in Web, Personalization and Feature Experimentation; Thompson sampling for binary metrics, epsilon-greedy for numeric ones; the model updates hourly (docs)
ResultsA winner when one price is at least 95% likely to be best, or when the rest are practically equivalent (expected relative loss under 0.5%)Bandit results show an estimated improvement over the original, without statistical significance
Sticky assignmentSigned first-party cookie; a user ID gives the same bucket on every deviceIn Feature Experimentation, a user profile service is recommended for sticky bucketing while a bandit runs
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 ReportedEvents you send; in Web Experimentation, from your page through the snippet API (docs)
Payment providersStripe, Polar, Lemon Squeezy, Dodo PaymentsAny: you report the revenue
SDK languagesServer only: TypeScript/JavaScript, Python, PHP, Ruby, GoAndroid, C#, Go, Flutter, Java, JavaScript, PHP, Python, React, React Native, Ruby, Swift (SDKs)
Pricing (Nov 2026)Free; Pro $29/month or $199/year; Lifetime $299 once (pricing)Not published; every plan is packaged individually and starts with a demo request (plans)

How do you run a price test in Optimizely?

There are two routes, depending on which Optimizely product you have.

In Web Experimentation, a variation changes the price shown on the page. The checkout still has to charge that price, so your server must know which variation each visitor is in and charge accordingly; changing the displayed number alone only tests a label. Revenue comes back through the snippet API from your page.

In Feature Experimentation, a flag rule (A/B or bandit) assigns the variation through the SDK on your server. Your code maps it to an amount, uses that amount on the pricing page and at checkout, and sends a revenue event when the purchase completes. While a bandit runs, Optimizely recommends a user profile service so visitors keep their variation.

Either way, Optimizely measures what you send it. A purchase your code fails to report, or a refund it never hears about, isn't in the result. Server-side price testing covers what the server half needs to get right.

How does Optimizely's bandit compare with Leverprice's?

Optimizely uses Thompson sampling when the metric is binary, such as a conversion, and epsilon-greedy when it's numeric: a small share of traffic goes evenly to every variation, and most goes to the one with the highest observed mean (docs). It weights recent behavior more heavily with exponential decay and updates the model hourly. You can't change the primary metric once the bandit starts, changing variations mid-test resets the model, and the docs say bandits generally take longer than A/B tests to identify winners and losers.

Leverprice runs Thompson sampling on revenue per visitor directly. Each visitor ends in one of three outcomes (kept purchase, refunded purchase, no purchase), the engine keeps Dirichlet posteriors over them, recomputes traffic weights every 5 minutes and keeps at least 5% of traffic on every price. Only visitors older than 30 minutes count, so fresh traffic doesn't look worse than it is.

The bigger difference is how each one ends. Optimizely's bandit reports an estimated improvement over the original and leaves the call to you. Leverprice stops on an explicit rule: one price at least 95% likely to be best, or the remaining prices practically equivalent, with expected relative loss under 0.5%. Then you lock in the winner with one click, and it's live for everyone in about a second. Bandit vs A/B testing for pricing covers when either approach is the better tool.

How long does a price test take?

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. Optimizely's docs say its bandits generally take longer than A/B tests to identify winners and losers (docs), and we haven't found comparable published figures for price tests on its platform. With either tool, the fastest way to shorten a test is to test prices further apart: in our 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 Optimizely if

  • You already license Optimizely and run experiments across several teams.
  • You want price tests in the same program as layout, copy and personalization tests, managed in one place.
  • Your revenue events are already instrumented, reconciled and trusted.
  • You sell through a provider Leverprice doesn't support, or through sales-assisted deals that your code reports.
  • You test whole pricing pages (layout, plan order, copy) as much as the amounts themselves.

Choose Leverprice if

  • Price amounts are what you want to test, and an enterprise contract is more than the job needs.
  • You want revenue from your payment provider, refunds included, instead of events you instrument and maintain.
  • You want the price decided on your server with your own bounds, a fallback within 500 ms, sticky assignment without an extra service, and crawlers kept out.
  • You want an explicit stopping rule based on each price's probability of being best and the expected loss of picking the leader.
  • You want regional prices per country, in the local currency, inside the same test.
  • You want published pricing you can start on now: Free, then $29/month or $199/year.

How do you use Optimizely and Leverprice together?

Keep Optimizely for layout, copy and personalization tests, and let Leverprice set the amount. Run them on different things: an Optimizely variation that rewrites the price element while Leverprice tests the amount leaves both results unreadable. If you want Optimizely results broken down by price, send the price each visitor saw (quote.price) along with the events you already report.

To move a running Optimizely price test over:

  1. Stop the Optimizely price experiment or bandit, and keep the price element out of new Optimizely variations.
  2. Call 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. Keep your Optimizely revenue events if other experiments use them. Leverprice doesn't need them.

Frequently asked questions

Does Optimizely have a multi-armed bandit?

Yes, in Web Experimentation, Personalization and Feature Experimentation. It uses Thompson sampling for binary metrics and epsilon-greedy for numeric ones (docs).

How much does Optimizely cost?

Optimizely doesn't publish prices. Every plan is packaged individually and starts with a demo request (plans).

Does Optimizely verify revenue with my payment provider?

Optimizely counts the revenue your code reports. In Web Experimentation it arrives from your page through the snippet API (docs), so reconciling it with Stripe or another provider is up to you.

Can a bandit tell me whether a price difference is significant?

Optimizely's bandit results don't report statistical significance; they show an estimated improvement over the original. Leverprice's stopping rule uses each price's probability of being best and the expected loss of picking the leader.