The Benchmark: Shoppex vs SellAuth, Komerza and Sell.app

Anyone can ship an ecommerce platform now. AI turned a weekend project into an afternoon project, and this space is drowning in the results. Shipping stopped being the hard part somewhere around 2024. What's still hard is engineering — tail latency under load, signed webhooks with replay protection, APIs that clean up after themselves. None of that shows up on a landing page. All of it shows up in a benchmark.

So we ran one. We'd made an offer that only makes sense if Shoppex actually beats the platforms we're asking you to leave, and claims like that deserve receipts. This post is the receipts: storefront speed, API latency, API depth, across Shoppex, SellAuth, Komerza and Sell.app. Methodology included, raw numbers included, and — this part matters — the places where we lost included.

Everything was measured on 2026-08-09 from one machine in Germany. Every test is reproducible, and only the authenticated section needs an account.

Storefront speed

The buyer-facing number. We ran Lighthouse against hosted storefronts on each platform: same machine, same settings, median of three runs per site.

Full medians below, including two more of our theme demos — and yes, including the column where we originally lost. More on that in a second.

Here's the story we could have quietly left out. The first run of this benchmark caught us. Our Total Blocking Time came back at nearly three seconds — worse than Sell.app's — and when we dug into the trace, the culprit wasn't our renderer at all. It was our own bot-protection JavaScript, taxing every single page load with about two seconds of main-thread work. A security setting we'd turned on and never measured. We switched it off the same afternoon, re-ran everything, and the scores you see above are the result: 0.95 or better on every theme, TBT down around 0.1 seconds. That's the entire argument for benchmarking your own stuff, compressed into one embarrassing afternoon.

Run it yourself:

npx lighthouse https://clean-minimal-demo.myshoppex.io --preset=perf --view

The public API: does it exist, and how fast is it

This one's for the developers — anyone running a custom storefront on their own domain, a Discord bot, anything headless. Before you can measure an API you have to find one, and that search turned out to be a result in itself:

SellAuth and Sell.app render product data into the page server-side, and we found no public JSON endpoint on either. Everything runs through key-gated server APIs. That's a legitimate architecture choice, to be clear. It just means "build your own frontend" starts with "build your own backend proxy", which is a strange first step to hand a customer.

For the two platforms where a public endpoint exists, we measured the single-product fetch — the request every product page makes. Twenty-five requests each, fresh connection every time:

This one has a story. Our first run put Komerza a touch ahead at the median (67 vs 76 ms), with a response half the size of ours — and we don't enjoy losing medians. So we shipped a version-invalidated response cache the same day, re-measured both platforms back to back, and now it's 63 vs 65 ms: a tie, with our p95 ahead at 92 vs 118. The tail is what your slowest visitors feel. Both APIs are fast, honestly. The real four-way difference isn't speed at all — it's that half the field has nothing public to measure.

API depth

Everything past the storefront runs on the merchant API — orders, licensing, affiliates, webhooks, automation. We counted the documented endpoints in each platform's public reference. Not marketing pages: the actual reference docs, all read on the same day.

Counts are a proxy, obviously. What ships around the API matters more:

And the parts that don't fit in a table row: 59 webhook event types, API keys scoped per resource and action across 28 resources, cursor pagination, per-key IP allowlists. All 302 reference pages are generated straight from the OpenAPI spec of the running code, which is why the docs can't drift from reality. Keep that last sentence in mind — it becomes relevant further down.

The authenticated API under load

Everything above needs no account. But a production integration lives on authenticated endpoints, so we benchmarked all four platforms through regular merchant accounts. Nothing whitelisted, nothing staged — standard accounts on each platform's free or base tier.

Which operations? We didn't guess. We looked at what real integrations actually call most on the Shoppex API, and the answer is unglamorous: list products, update product, list orders, list reviews, fetch a single order, poll a payment's status, create things. Bots syncing stock and prices, bots polling whether a payment cleared, cron jobs paging through orders. That's what automation does all day, so that's what we measured — eight operations, on every platform that supports them.

Method: 30 recorded requests per operation after 3 warmups, sequential with 0.6 s spacing, fresh connection each time, measured from Germany on 2026-08-09. Every object the benchmark created got deleted afterwards. (Well — everywhere deletion was possible. Hold that thought.)

The table says something the bars can't: look at the tail. Our worst p99 across all eight operations is 403 ms — and that's the one that creates an invoice, writes a customer, and mints a payment URL in a single call. Every other platform has at least one operation with a p99 above 590 ms, and Sell.app's order list hit 4.7 seconds. If your cron pages through orders or your bot batch-updates products, the p99 is the difference between an integration that feels instant and one that feels broken.

Now the footnotes we promised, because a benchmark that only reports its wins is an ad. SellAuth beats us on update-product outright — faster at every percentile, 144 vs 193 ms at p95 — and their medians on create-product and checkout-session creation are quicker than ours too. Credit where due; their tails are where it comes back. SellAuth was also the only platform that rate-limited us, throwing 429s on checkout creation after about 25 sequential requests. Reasonable protection, but undocumented: none of the three publishes numeric rate limits, while Shoppex sends x-ratelimit-* headers on every response. And one artifact we couldn't clean up no matter how much we wanted to: SellAuth and Sell.app let you create billing objects through their APIs but offer no way to delete them, so our test invoices and zero-value charges are still sitting there. Sorry. On Shoppex, every object the benchmark created was deleted through the same API that created it.

Webhook delivery: the invisible benchmark

Webhooks are how your bot finds out something happened — a sale, a new order, a stock change. Nobody benchmarks them because they don't show up on any status page. Which is precisely why we did. One receiver, ten real events per platform, measured from API call to received webhook.

Sit with that chart for a moment. If a buyer pays and your Discord bot delivers the key off the webhook, that buyer waits eleven seconds on Komerza. On Shoppex they don't wait at all — every one of our ten deliveries landed faster than the receiver could timestamp it. Sell.app might deliver webhooks fine in other flows, and the zero-value test charges are a plausible explanation for the silence. But those were the only charges their API would let us create, on the exact field their docs advertise for exactly this purpose.

When the docs describe an API that does not exist

We didn't go looking for this one. It kept finding us. Three separate times during this benchmark, Sell.app's documentation described something their live API doesn't have:

1. The docs tell new integrations to prefer /v2/orders. The live API answers 404. We had to fall back to /v2/invoices.
2. The docs describe webhook channels under /v2/webhook-channels, nine endpoints deep. The live route answers 404.
3. The docs promise charge.created webhooks on the per-charge webhook_url field. Ten charges, one receiver, zero deliveries.

There's a word people in this space love throwing at each other's platforms: slop. Here's the thing — slop isn't about who used AI or how fast you shipped. Slop is measurable. It's documentation describing endpoints that don't exist. It's a 4.7-second p99 on the endpoint every integration polls. It's webhooks that never arrive, on the exact field the docs advertise. A developer burns hours on that before discovering the bug was never on their side.

Our 302 reference pages are generated from the OpenAPI spec of the running code, and CI fails the build when they drift. Our docs can't describe an API that doesn't exist, because no human writes them. Judge every platform — ours very much included — by what you can measure. That's what this post is for.

The scoreboard

Twelve benchmarks in this post produced a clear winner. The tally:

Eleven out of twelve. SellAuth takes update-product, fair and square. A ranking compresses away a lot of nuance though, so treat this table as the index rather than the verdict — the sections above hold every number, every method, and every place where the picture was less flattering for us, including the afternoon our own bot protection turned up in our own trace.

Reproducibility

The storefront and public-API sections are reproducible tonight, by anyone, without an account anywhere. The authenticated section needs your own API keys, but any regular account on each platform works — nothing about the method depends on who's asking. That's the standard we think platform comparisons should be held to, and if you rerun any of this and get materially different numbers, we genuinely want to hear about it.

Did the numbers move you? Then the offer stands until September 30, 2026: six months of Shoppex Business, free, for anyone switching from a paid competitor. Or start on the compare page and check our claims line by line.