Checked 8 Sep 2026
Solvr vs Salamoonder
A points-metered task queue across many vendors, compared with a priced-in-dollars API for Kasada and DataDome.
Salamoonder runs a createTask / getTaskResult queue covering Kasada, DataDome, Akamai, Incapsula and a set of Twitch-specific tasks, billed out of a points balance. We do Kasada and DataDome, each surface priced in dollars on a public page, with a synchronous endpoint alongside the async one, the grade returned on every solve, and a ledger row per solve. The honest headline: they are broader, we are more legible.
$5 minimum no subscription failed solves cost nothing
At a glance
Solvr
Salamoonder
- per 1,000
- $2.00 not published
- Vendors covered
- Kasada and DataDome four plus Twitch
- Priced in
- dollars, publicly points, unpublished
- API shapes
- sync + async create + poll
- Proof-of-work (cd)
- free metered
- Grade returned
- yes no
compiled from salamoonder.com on 8 Sep 2026 · ours read live from this app
They are the better choice sometimes.
no vendor wins every row
Pick Salamoonder if
- You need Akamai or Incapsula as well as Kasada and DataDome, or the Twitch-specific integrity tasks they have built around.
- You are already integrated against their
createTaskshape and the switching cost outweighs the difference. - Their wrappers for Python, Go and Node match your stack and you would rather not write the client.
Pick Solvr if
- You want to know the price before you deposit. Ours is $2.00 per 1,000, on the pricing page, not behind a points conversion.
- You would rather hold a connection for five seconds than poll a task queue — we offer both shapes on the same key at the same price.
- You need the grading verdict back to audit the success rate yourself, rather than a token and a trust exercise.
- You want signed webhooks, typed error kinds and an exportable per-solve ledger for whoever is on call.
Row by row
Solvr vs Salamoonder, row by row.
Anything we could not verify from a public page reads not published rather than a guess. If you work at Salamoonder and a row is wrong, tell us and we will fix it.
four groups · their side from their docs
| Capability | Solvr | Salamoonder |
|---|---|---|
| Billing | ||
| Kasada, per 1,000 Theirs converts through a points balance. Ours is a dollar figure on a public page. | $2.00 | points · rate not published |
| Proof-of-work (cd) Kasada wants a fresh cd on every request, so this line item scales with your traffic rather than with your solves. | free | metered · 50 points |
| Failed solves We meter successes and failures on separate counters, so a failure never reaches your balance and there is no refund to chase. | never billed | not published |
| What counts as a success A weak Kasada verdict is refused upstream here and never becomes a billable bundle. | strong grade only | not stated |
| Price on the public site This is the row the rest of the page is really about. | yes | no |
| Ledger you can export Target, outcome, latency, grade and exact cost on every row. | per solve, CSV | not published |
| Coverage | ||
| Kasada | yes | yes |
| DataDome Both. Ours: The "checking your device" page and the slider puzzle. You keep your own connection; we tell you exactly what to send so it waves you through. | yes | yes |
| Akamai | no | yes |
| Incapsula | no | yes |
| Twitch integrity tasks They have dedicated task types for it. We solve the wall and leave the product-specific plumbing to you. | via Kasada solve | purpose-built tasks |
| API | ||
| Solve in one call You own the network, we run the script: ~200ms, answer in the first response, no task to poll. Theirs is create-then-poll whatever you are solving. | POST /api/kasada/payload | no |
| Full-network solve Both submit-and-collect, because both wait on your proxy — five of those six seconds are the network, not the solve. Ours also delivers by signed webhook, so the polling is optional. | POST /api/tasks | createTask |
| Collecting the result Polling is a cost you pay in latency and requests. A signed webhook is a cost we pay. | poll or webhook | getTaskResult poll |
| Signed webhooks The timestamp sits inside the signed string, so a captured delivery cannot be replayed. | HMAC · 5 retries | not published |
| Grade returned to you The difference between a success rate you are told and one you can measure. | r + script version | not returned |
| Typed error kinds bad_fingerprint, upstream_timeout, rejected, busy — with the retryable ones flagged as retryable. | yes | error codes |
| Bring your own proxy Both support it. Ours never touches disk — debug records keep scheme, host and port and drop the credentials. | per request | per task |
| MCP server Claude Code, Cursor, Codex and anything else speaking the protocol. | yes | no |
| SDKs Theirs, including community wrappers. Worth something on day one. | curl and MCP | Python, Go, Node |
| Operations | ||
| Limit model You are limited on how many run at once, matched to spend over a rolling window, because RPM is the wrong unit for something that takes five seconds. | concurrency tiers | not published |
| Published latency We publish it because the sync endpoint holds your connection for the whole solve, and you should size timeouts against the truth. | median 5–6s · 45s deadline | not published |
| Token retention Bundles are IP-bound, single-use and live for minutes. Holding short-lived credentials longer is liability with no upside. | stripped within hours | not published |
| Payment methods Visa, Mastercard and Amex via Stripe, or eight coins via Cryptomus. | card and crypto | crypto |
| Support | Telegram and email | Discord and Telegram |
- ok
- better here
- bad
- worse here
- warn
- partial, gated or caveated
- neutral
- a fact, not a score
Cost
What the workload costs.
Successful solves only. We do not bill a failure, so ours are close to the real numbers rather than the sticker ones.
Salamoonder meters in points rather than dollars — documented as 1,000 points for a ct solution and 50 for a cd. The dollar value of a point is not on their public site, so a like-for-like column cannot be printed here without inventing one.
$0.00
per proof-of-work, here.
Kasada wants a fresh cd on every
request, so a crawl needs one per page rather than one per solve. A per-cd charge is
the line item that tracks your traffic instead of your solve count, and it is the one
most worth pricing out before you commit.
| Successful solves | Solvr | Proof-of-work | Salamoonder |
|---|---|---|---|
| 1,000 | $2.00 | $0.00 | not published |
| 10,000 | $20.00 | $0.00 | not published |
| 100,000 | $200.00 | $0.00 | not published |
| 1,000,000 | $2,000.00 | $0.00 | not published |
minimum top-up · Solvr $5 · Salamoonder not published credit never expires on either side
The differences that don't fit in a cell.
- $2.00 / 1,000 A price, in dollars, on a page
- Points balances are a pricing decision, not an accounting one: they put a conversion between you and the number, and the conversion belongs to the vendor. Ours is two dollars per thousand Kasada solves, every other surface printed beside it on the pricing page, and the ledger is denominated in micros so the arithmetic never rounds against you.
- $0.00 per cd The proof-of-work costs nothing
- Kasada demands a fresh cd on every single request, so ten thousand pages is ten thousand of them. Metered per-cd pricing means your bill tracks your traffic rather than your solves. We mint them free and uncapped, because charging for it would be charging you for integrating correctly.
- sync and async One call, not create-then-poll
- Hold the connection and take the bundle in the response, or submit and let a signed webhook bring it to you. A queue-only API makes every caller write the same polling loop, and every polling loop adds latency nobody asked for on top of the solve itself.
- r + version The grading verdict comes back
- Kasada grades every session. We return that grade and the script generation with each bundle, so you can correlate our output against your own downstream accept rate. Everyone in this market claims a number in the high nineties; almost nobody hands you the means to check it.
- typed kinds Errors you can branch on
- bad_fingerprint, upstream_timeout, rejected, busy — a named kind on every failure with the retryable ones flagged, instead of a status code and a guess. Retryable failures are released and reattempted before you ever see them.
- MCP · same key Your agent can call it directly
- We run a remote Model Context Protocol server. An agent that hits a Kasada wall mid-task calls solve and carries on. Same API key, same concurrency rules, same balance.
Migration
Two calls become one.
Their shape is createTask then getTaskResult on a loop. Ours is a POST that returns the bundle — or the same submit-and-collect pattern if that is what you want, with a signed webhook instead of the loop.
Full API reference →$ curl -X POST https://salamoonder.com/api/createTask \
-d '{"api_key":"…","task":{"type":"KasadaCaptchaSolver",
"pjs":"https://…/p.js","cd_only":"false"}}'
200 { "taskId": "…" }
# then loop until it is ready
$ curl -X POST https://salamoonder.com/api/getTaskResult \
-d '{"api_key":"…","taskId":"…"}'
200 { "status": "processing" } ← sleep, retry$ curl -X POST app.getsolvr.io/api/kasada/payload \
-H "X-API-Key: solv_live_…" \
-d '{"script_content":"…","script_url":"…",
"version":"j-1.2.661"}'
200 {
"status": "success",
"transform": {
"tl_url": "https://…/tl",
"headers": { … },
"payload": "<base64>",
"user_agent": "Mozilla/5.0 …"
}
}
# ~200ms. no loop. no points conversion. one row on the ledger.Questions
Salamoonder, asked and answered.
Including the ones where the answer is not the one we would have chosen.
How much does Salamoonder cost per 1,000 Kasada solves?
They meter in points rather than dollars and do not publish the conversion on their public site, so we are not going to print a number we would be guessing at. Their documentation describes 1,000 points for a ct solution and 50 for a cd. Ours is $2.00 per 1,000 solves, with the proof-of-work endpoint free.
What is the difference between createTask and a synchronous solve?
createTask hands you a task id and you poll getTaskResult until it is ready — two calls plus a sleep loop, and the poll interval is added to every solve’s wall-clock time. Our sync endpoint holds the connection and returns the bundle in the response. We also offer the async shape, with a signed webhook so you need not poll at all.
Which vendors does each one cover?
Salamoonder covers Kasada, DataDome, Akamai and Incapsula, plus a set of Twitch-specific tasks. We cover Kasada and DataDome, each priced per surface. If your blockers go past those, their breadth is a real reason to pick them.
Do either of you charge for the Kasada proof-of-work?
They document a per-cd cost in points. We charge nothing for it, with no cap. Kasada requires a fresh cd on every request, so on a crawl this is the line item that tracks your traffic rather than your solve count — worth doing the arithmetic on before comparing headline rates.
Can I run both?
Yes, and while you are evaluating you probably should. Both are prepaid with no subscription. Send the same workload through each for a week and compare downstream accept rates, which is the only number that is actually yours.
Other comparisons
Sources
Salamoonder figures compiled from salamoonder.com and its public documentation on 8 Sep 2026. Ours are read out of this application at render time. Salamoonder is not affiliated with Solvr, and the name is used only to identify their product.