SolidPeer — Pricing Proposal

Competitive analysis of an EVM-market reference (QuickNode) plus a proposed tier structure for the BCH gateway.

Status

Committed launch pricing. Per-tier dollar values, monthly grants, and the CC-to-fiat peg (top-up rate, minimum, Dedicated floor, headline) are committed; per-method CC weights stay calibration-pending until Cashonize-on-mainnet generates representative traffic (memory:project_calibration_trigger). The tier shape is load-bearing; the per-method weights inside that shape will get small adjustments post-launch.

1. Reference: QuickNode pricing

QuickNode is the closest scale reference for what an EVM/Solana RPC business looks like at maturity. Public pricing as of fetch:

Effective $/M credits at included quota: $0.50 (Business) → $0.62 (Build). Tier price difference is mostly RPS unlock and feature gating (trace/debug, archive, streams, dedicated, support SLA), not the per-credit price itself.

QuickNode's billing model: Method Responses × Multiplier = API Credits — same shape as ours. Cheap EVM methods (eth_blockNumber, eth_getBalance, eth_call, eth_sendRawTransaction) cost ~30 credits each. Heavier methods (eth_getLogs, debug_traceBlock) scale up to 75–1000+.

Per-cheap-call dollar cost for QuickNode: 30 credits × $0.50/M = **$1.5×10⁻⁵ per call**. A wallet polling once per minute consumes ~1.3M credits/month → ~$0.65 worth of credits. That's the unit economics they're optimizing against.

Tier feature gates worth noting:

• Free: archive data, all chains, community support, no overage allowed.
• Build: trace/debug, advanced metrics, S3/Postgres storage, 24h ticket SLA.
• Accelerate: per-method rate limiting, 100 active streams (subscriptions), 12h SLA.
• Scale: 8h SLA.
• Business: full crypto billing, 4h SLA.
• Enterprise: dedicated clusters, SSO/SAML, RBAC, SOC1/SOC2 Type 2.

2. BCH-market positioning

We are not at QuickNode-level demand and shouldn't price as if we are. Four realities shape the proposal:

1. Smaller user base. BCH ecosystem volume is materially smaller than EVM/Solana. Per-user infrastructure amortization is worse than QuickNode's.

2. The actual competition is not another paid service — it's free hobbyist infrastructure. Users today choose between:

   • Self-hosting (~$200–500/mo infra + operator time) — our practical price ceiling.
   • Free public Fulcrum / BCHN endpoints operated by community members and small businesses as a public good. These work fine in calm times and get easily overwhelmed by any new project's load. Most hobbyist BCH apps run on these today, and the recurring failure mode is "the free endpoint fell over the day my user base grew." That's our addressable market — and it's a fragility alternative, not a cost one.

3. Specialty features. Chaingraph GraphQL (queries + live WebSocket subscriptions), CashToken support, dsproof, Fulcrum scripthash subscriptions on busy addresses — first-class here in ways generic RPC services don't cover.

4. Reliability is the primary value prop, not features. Our differentiator versus the free public infra is uptime, predictable rate limits, SLA backing, and not sharing throughput with hundreds of other random apps. The pitch is "predictability is worth more than free-but-unreliable," which holds for any project whose users notice when their wallet stops loading mid-day.

These argue for:

• Don't scare off hobbyists currently on free public infra. The entry tier (Hobby $9.99) has to feel approachable to someone who has never paid for blockchain RPC.
• Position the messaging on reliability, not feature breadth. Pricing-page copy should lead with availability and predictability, not with method allowlists.
• Make the free-infra → Hobby switch frictionless — a project whose free public endpoint just broke needs to move over in minutes, not days.
• Slightly higher $/credit than QuickNode (no race-to-bottom pressure, smaller amortization), smaller tier quotas sized to realistic BCH usage, lower entry dollar amount to clear the "I was getting this free" psychological bar.

3. Proposed tiers

Burst is the size of the per-account token bucket (instantaneous spike capacity). The bucket refills at the steady-state RPS rate, so a 25-RPS Hobby account can absorb a 500-request spike at cold-start, then return to 25/sec sustained. Sized 20× RPS so a typical wallet cold-start (Cashonize fans out 200–700 RPS for under 1 second downloading tx history) never sees a 429.

CC quotas are mapped at 10× QuickNode's per-tier API credit grants (where QN tiers align by name); per-method costs in code use a 100-base unit (cheapest method = 100 CC, ~3× QN's 30-credit cheap-call), so the per-cheap-call dollar cost lands meaningfully below QN. Combined with our higher CC burn rate per call (we cost-weight per-method by complexity instead of QN's flat 30 credits per call), the headline "5× cheaper than QN" softens to ~1.5–3× cheaper on real-mix workloads — which is the actual launch positioning.

No free trial. The lowest paid tier (Hobby $9.99/mo) is the entry point; we don't run a $0 evaluation cohort. Three reasons:

1. Trial-fraud defense (one-time-per-identity verification, KYC, device fingerprinting) is non-trivial engineering for marginal sales lift.
2. $9.99/mo is genuinely lunch money for any working developer — the friction-vs-cost tradeoff favors a serious paid product over a free-trial-then-convert funnel.
3. The single-machine self-host (compose/single/) is open source. Curious developers can run their own gateway locally for free against any network they want; the paid product is for operators who don't want to run their own infrastructure.

This trades off marketing leverage against QuickNode's "Free Trial 10M credits" — we accept the lost top-of-funnel hook in exchange for a cleaner B2B-paid posture.

Testnet + regtest pricing (chipnet, testnet4, regtest)

Testnet and regtest usage is billed at half the mainnet rate across all paying tiers — chipnet, testnet4, and regtest requests cost 0.5× the mainnet CC for the same method. The discount tracks the smaller infra footprint of these networks (smaller chains, lower load) while still covering operational cost; previous "free testnets" framing made it impossible to recover the meaningful infra spend that real-world testnet workloads (CI pipelines, integration suites, demo apps) actually generate.

The per-network rate is configured in gateway/src/types.ts (NETWORK_RATE map) and applied at every charge site (reservation, commit, cache hit). To make a network free, set its rate to 0.

What still applies on testnets/regtest:

• Per-tier rate limits (RPS, max concurrent subs) — combined caps across all networks.
• Concurrent connection / subscription caps — same global cap regardless of network.
• Per-token network scope — a token can be scoped to chipnet-only (safe for CI/CD), or mainnet-only, etc. Default scope: all networks.

The audit log records the discounted figure in cc_charged — both mainnet (full) and testnet/regtest (half) charges show up, tagged by network, so dashboards can break down revenue per network.

No overage; hard 429 at zero balance. Crypto-only billing rules out auto-charging a card to absorb overage, so once the cycle's CC quota is exhausted requests are rejected with rejected:balance until the customer tops up, upgrades, or the cycle renews. See BILLING.md for the full mechanics. Annual discount: ~17% on monthly tiers (matches QuickNode pattern, standard SaaS). BCH-native payment: accept BCH directly + stablecoins. (BCH-native is a real differentiator for our audience; no traditional cards in the launch shape — see BILLING.md §1.)

Canonical tier spec

Implementation contract. The runtime config consumes this shape; numbers below match billing-service/src/tiers.ts 1:1.

const TIERS = {
  hobby: {
    kind: 'monthly',
    price_usd_monthly: 9.99,
    price_usd_annual: 99.90,                     // ~17% discount
    cc_quota_monthly: 300_000_000,               // 300M CC (entry-paid tier; below QN's Build, sized for hobbyist + small-app load)
    rps: 25,
    burst: 500,                                  // 20× rps; covers wallet cold-start fan-out
    max_tokens: 3,
    max_concurrent_subs: 25,
    tx_broadcast: true,
    per_token_method_scope: false,
    per_token_rps_cap: false,
    per_token_sub_budgets: false,
    per_token_cache_opt_in: false,
    webhooks_on_events: false,
    dashboard: 'basic',
    support: 'email_48h',
    dedicated_backend: false,
    sso: false,
  },

  build: {
    kind: 'monthly',
    price_usd_monthly: 39.99,
    price_usd_annual: 399.90,
    cc_quota_monthly: 1_300_000_000,             // 1.3B CC (10× QN Build 80M would be 800M; bumped to 1.3B to put Build's $/M CC between Hobby's $0.0333 and Business's $0.0300, monotonizing the volume-discount curve)
    rps: 75,
    burst: 1_500,                                // 20× rps
    max_tokens: 10,
    max_concurrent_subs: 100,
    tx_broadcast: true,
    per_token_method_scope: true,                // can issue read-only tokens
    per_token_rps_cap: true,                     // can cap a single token's RPS for security
    per_token_sub_budgets: false,
    per_token_cache_opt_in: true,                // per-token TTL overrides
    webhooks_on_events: false,
    dashboard: 'full',
    support: 'email_24h',
    dedicated_backend: false,
    sso: false,
  },

  scale: {
    kind: 'monthly',
    price_usd_monthly: 199.99,
    price_usd_annual: 1999.90,
    cc_quota_monthly: 9_500_000_000,             // 9.5B CC (= 10× QN Scale 950M credits)
    rps: 200,
    burst: 4_000,                                // 20× rps
    max_tokens: 25,
    max_concurrent_subs: 500,
    tx_broadcast: true,
    per_token_method_scope: true,
    per_token_rps_cap: true,
    per_token_sub_budgets: true,                 // per-token CC caps
    per_token_cache_opt_in: true,
    webhooks_on_events: true,
    dashboard: 'full',
    support: 'email_12h',
    dedicated_backend: false,
    sso: false,
  },

  business: {
    kind: 'monthly',
    price_usd_monthly: 599.99,
    price_usd_annual: 5999.90,
    cc_quota_monthly: 20_000_000_000,            // 20B CC (= 10× QN Business 2B credits)
    rps: 500,
    burst: 10_000,                               // 20× rps
    max_tokens: 50,
    max_concurrent_subs: 2500,
    tx_broadcast: true,
    per_token_method_scope: true,
    per_token_rps_cap: true,
    per_token_sub_budgets: true,
    per_token_cache_opt_in: true,
    webhooks_on_events: true,
    dashboard: 'full',
    support: 'email_4h',
    dedicated_backend: false,
    sso: false,
  },

  dedicated: {
    kind: 'monthly',
    price_usd_monthly: 'custom',                 // floor $1500/mo proposal in TODO.md
    cc_quota_monthly: 'custom',
    rps: 'custom',
    burst: 'custom',
    max_tokens: 'custom',
    max_concurrent_subs: 'custom',
    tx_broadcast: true,
    per_token_method_scope: true,
    per_token_rps_cap: true,
    per_token_sub_budgets: true,
    per_token_cache_opt_in: true,
    webhooks_on_events: true,
    dashboard: 'full',
    support: 'dedicated',                        // dedicated channel
    dedicated_backend: true,                     // routing_policy = dedicated:<id>
    sso: true,                                   // SSO/SAML/RBAC
    custom_sla: true,
  },
} as const;

COGS sketch (Hetzner Robot consolidated, launch phase)

Infrastructure cost target is set by the Hetzner deployment plan in ARCHITECTURE.md. Robot dedicated for backends with consolidation onto large boxes is dramatically cheaper than separate-box-per-service.

Launch-phase baseline (0–500 active users):

Growth-phase (500–5,000 active users): services split to dedicated per-role boxes — closer to ~€600–1000/mo as originally estimated.

Implied break-even user counts at launch-phase baseline (€230/mo) and proposed pricing:

Hobby is healthier than initially modeled — even modest signup numbers cover infrastructure at launch. The "100 users to break even" math from the older estimate doesn't hold under consolidation; the value-prop framing of Hobby as approachable on-ramp still does. With no free trial, Hobby is the entry point to the funnel; the $9.99/mo price keeps it accessible while the 300M-CC grant gives serious-evaluation headroom (a developer can run a real prototype against mainnet for weeks before hitting cap).

Dedicated tier scales differently: each customer gets ≈€600–1000/mo of dedicated infrastructure plus cloud-tier overhead; the proposed $1500/mo floor gives ~30–40% gross margin per customer. Lower percentage than shared tiers but high absolute revenue.

Implied dollar economics

Headline marketing peg: from $0.02 / 1M credits (Scale's effective rate as the published "best volume rate"). Mirrors how AWS / QuickNode market a "starting at" volume number rather than quoting four different per-tier figures.

Our cheapest method costs 100 CC (vs ~30 credits at QuickNode — they use a flat-30-credit cost for almost every cheap RPC; we cost-weight per-method, so a typical-mix workload averages closer to 200–500 CC per call). Per-cheap-call cost lands at:

The 3–7× cheaper-per-cheap-call number is the headline. The real-mix number is meaningfully tighter: our higher CC burn rate per call (per-method weights of 100–800 CC vs QN's flat 30) means a typical wallet workload — mix of getblockchaininfo, getblockhash, scripthash subscribes — burns ~3–5× more of our CC than QN's credit count for the equivalent calls. So real-mix per-call cost lands ~1.5–3× cheaper than QN, not 5–7×. That's the actual launch positioning: meaningfully cheaper than QuickNode on real workloads, not implausibly so.

Per-CC rate ladder (descending): Hobby $0.0333 → Build $0.0308 → Business $0.0300 → Scale $0.0211. Hobby is intentionally subsidized as the entry-tier loss leader; Scale is the volume sweet spot; Business pays for features (SLA, support, dedicated capacity hints) more than for credits — its slightly-cheaper-than-Build per-CC rate is the floor the volume-discount story rests on without overpaying for the tier-ladder shape. Build's grant of 1.3B (vs the strict 10× QN Build = 800M) is the calibration adjustment that makes the ladder monotonic.

Headline positioning: ~1.5–3× cheaper than QuickNode per real-mix call (3–7× on the cheapest synthetic call, but real workloads aren't all-cheap-RPC). That's the launch posture — measurably cheaper than the mature reference, without being implausibly cheap.

4. Feature matrix

Per-token RPS cap is a security feature: the per-account RPS budget from §3 caps the aggregate across all of an account's tokens, but a paid customer at Build+ can additionally set a per-token cap (Token.optional_caps.rps_cap) that limits a single token's burst rate. Use case: bound the blast radius of a leaked browser-deployed key — if your front-end token is capped at 5 RPS but your account has 200 RPS, a leaked front-end key can drain at most 5 RPS instead of the whole account budget. Independent from allowed_origins (origin restriction) and allowed_methods (method scope) — together they give Build+ customers a tight blast-radius-limited surface for browser-deployed credentials. Hobby tokens use the account-level cap only; per-token override is a feature gate.

The "Dedicated" tier is the per-account dedicated:<backend_id> routing policy from ARCHITECTURE.md — same proxy hot path, exclusive backend stack. Pricing custom because infra cost varies (Fulcrum-heavy vs Chaingraph-heavy customers have very different stack profiles).

5. Sanity-check usage profiles

To validate the quotas, project realistic CC consumption against representative profiles. Subscriptions are the right pattern; polling-only wallets burn budget much faster (this is correct pricing — we want to incentivize subscriptions).

Indie wallet developer (≈ Hobby):

• 100 active users, ~5 watched scripthashes each, ~5 events/user/day
• 100 × 5 × 5 × 30 = 75k pushes/mo × 1000 CC = 75M CC
• Plus occasional broadcasts and queries: ~20M CC
• Total ~95M CC/mo — fits Hobby (300M CC) comfortably with ~3× headroom for traffic spikes.

Production wallet (≈ Build):

• 1000 users, similar pattern
• ~750M pushes/mo + queries + broadcasts → ~500M CC/mo at steady state, with subscription churn pushing closer to 800M CC.
• Build (1.3B CC) covers typical months with comfortable headroom; only sustained 1.5×-typical traffic hits zero mid-cycle and prompts a top-up or Scale upgrade.

Mid-size dapp / wallet (≈ Scale):

• 5000–10000 users, mix of subscription-using and polling clients
• ~2.5–5B CC/mo
• Scale (9.5B CC) comfortably covers this range; only the heaviest mid-size operators feel the ceiling.

Large wallet operator (≈ Business / Dedicated):

• 50k–100k users
• ~25–50B CC/mo
• Hits Business and tops up frequently. At this volume, dedicated infrastructure makes sense — the per-instance fee in Dedicated removes the cycle-end re-up cadence and gives capacity headroom that doesn't depend on top-up timing.

Heavy GraphQL analytics user (Build / Scale, edge case):

• Single power user running complex Chaingraph queries
• Each query 50k complexity × 1000 multiplier = ~50M CC
• 100 queries/day × 30 = ~150B CC/mo if unconstrained
• Will hit caps fast on any tier; query-complexity rejection by proxy will throttle them. Forces them to refine queries — the design intent.

6. Pricing rationale (why these numbers)

Why pricing has to clear the "free public infra" bar:

• Most BCH apps today run on free public Fulcrum / BCHN endpoints operated by community members. That works until it doesn't — public endpoints get overwhelmed when any new project's user base grows, and the failure mode is silent (your users see "loading…" forever).
• Our pitch is availability, not features. The reason to pay us is: your service stays up when the public endpoint falls over. That's worth real money to a project whose income depends on the app working at peak times.
• This is also the reason the entry tier has to be approachable. A user who has never paid for blockchain RPC is the user we need to convert; charging $49/mo on day one is the wrong way to introduce that conversation.

Why no free tier (vs QuickNode's Free Trial):

• A 10M CC/mo recurring free tier attracts re-registration abuse — every new email == a fresh 10M-CC budget. At our scale, that's a meaningful slice of a small operator's total budget.
• A one-time Trial avoids the recurring-abuse vector but introduces its own engineering tax: one-time-per-identity verification, KYC-lite, device fingerprinting, IP/subnet cooldowns. None of that is free to build, and most of it is fragile against motivated abuse.
• The alternative we're really displacing is self-hosting — and compose/single/ is open source. Curious developers who want to evaluate the gateway can run their own locally for $0; nothing about that requires our infrastructure. The paid product is for operators who don't want to run their own.
• $9.99/mo Hobby is a low enough barrier that "I'll try it" is a viable purchase decision for any working developer. We'd rather have a clean B2B-paid posture than chase top-of-funnel hooks against QuickNode.

Why $9.99 entry tier (vs QuickNode's $49):

• BCH developer audience skews more indie/hobbyist than EVM
• Self-hosting is the alternative we're really displacing; we need to clear the "cheaper than running a VPS" bar
• $9.99 is a low-friction "I'll try it" price point; $49 is "I need a justification."

Why $199.99 / $599.99 mid-tiers (vs QuickNode's $249 / $499):

• Stays comparable in dollar terms — we don't undercut at production tiers
• Quota proportional smaller (3B vs 950M for similar tier price) reflects: smaller per-call cost optimization on our end is not yet there, and our calibration constants are placeholders.
• Will tighten as usage data lets us peg per-call costs better.

Why Dedicated isn't simply "Enterprise":

• For BCH market, "Enterprise" connotations (compliance, RBAC, SOC2) are less universally relevant. The thing that is relevant is dedicated infra — no noisy-neighbor risk for trading-desk or exchange-grade customers.
• Pricing custom because the cost is dominated by per-stack infra ($200–500/mo fixed), not by metered CC usage.

Why no overage (hard 429 at zero balance):

• Crypto-only billing — we don't hold a card or pre-authorized wallet pull, so we can't auto-charge an overage. The QuickNode-Standard "auto-scale and bill the difference" model isn't available to us.
• Closer to QuickNode's newer Flat Rate RPS plan: at the cap, requests get HTTP 429 and the customer's app is expected to retry or the customer is expected to top up / upgrade.
• The customer's escape hatches stay rich (top up §7, upgrade §5, wait for renewal) so the hard cap doesn't translate to a hard outage — just a forcing function.
• Removes a whole class of bill-shock incidents (runaway client → uncapped overage charge) that competitors who do offer auto-overage routinely apologize for.

Why no "Trace/Debug" tier gate (despite QuickNode having one):

• BCHN doesn't have user-facing trace/debug equivalents (those are operator-only and not in our allowlist)
• Our equivalent unlock is per-token-feature gates: write authorization (broadcast), per-token cache control, per-token sub-budgets — gated at higher tiers

7. Open / pending decisions

These should move into TODO.md as commercial decisions to be made before launch:

1. Final CC-to-fiat peg. ✅ Committed: per-tier $/M CC = (Hobby $0.0333, Build $0.0308, Scale $0.0211, Business $0.0300); top-ups at the customer's tier rate (no premium); minimum top-up $5 USD-equivalent; Dedicated top-up floor $0.0200/M CC; headline marketing peg "from $0.02 / 1M credits". Empirical recalibration of per-method CC weights still pending Cashonize-on-mainnet (memory:project_calibration_trigger).
2. Annual discount %. 17% matches QuickNode; could be more aggressive (25%) to incentivize commitment for cashflow predictability.
3. Crypto-native discount? A 5–10% discount for BCH-paid subscribers could drive ecosystem alignment — strategic decision, low cost.
4. Per-system pricing differentiation? Currently all systems share the account budget at unified per-method cost. Alternative: dedicated Fulcrum-only or Chaingraph-only tiers for users who only need one.
5. Per-region pricing differentiation? Phase 6 question (multi-region — see ARCHITECTURE.md "Multi-region strategy"). All tiers are globally flat in the current proposal. Consider whether Dedicated-tier pricing varies by region. Likely defer; keep flat at launch.
6. Subscription cap enforcement. Tier-specific concurrent-sub limits assume the open "concurrent request cap" item from TODO.md is implemented. Pricing depends on that mechanic existing.
7. Dedicated-tier minimums. Bottom of Dedicated should have a clear floor — e.g., $1500/mo minimum — since otherwise customers on the boundary between Business and Dedicated will negotiate down.
8. Volume discounts. Above-Business-tier customers whose top-up cadence puts effective monthly burn >25B CC should be offered a Dedicated proposal proactively. Define the threshold.
9. Build tier monotonization. ✅ Resolved: Build grant bumped 800M → 1.3B CC ($0.0308/M; sits between Hobby's $0.0333 and Business's $0.0300). Per-CC rate ladder is now monotonic descending (Hobby > Build > Business > Scale).

8. Summary

• Pricing shape: 5 levels — Hobby, Build, Scale, Business, Dedicated. All paid; no free trial (the open-source compose/single/ self-host fills the "evaluate before paying" role). Lower entry price than QuickNode ($9.99 vs $49) and tier quotas mapped at 10× QN's per-tier credit grants (where tier names align).
• Per-credit price ~17× lower than QuickNode in nominal $/M-credit terms (Hobby $0.0333/M vs QN $0.55/M); per-cheap-call cost ~3–7× lower because our cheapest method costs 100 CC vs QN's flat 30 credits. On real-mix workloads (where most calls aren't the cheapest one) the gap is closer to 1.5–3× cheaper. Either way: meaningfully cheaper than QN, not implausibly so.
• Real competitor is self-hosting (~$200–500/mo); pricing has to clear the "cheaper than running a VPS" bar at the bottom while remaining sustainable at scale.
• Tier feature gates focus on per-token write auth, per-token caps, dedicated infra, and SLA — matching our architecture's natural unlock points.
• Usage profiles validated: indie wallets fit Hobby, production wallets fit Build/Scale, large operators move to Business or Dedicated. Subscription-heavy patterns are cheaper than polling, which is the intended incentive.