Product

The whole commerce engine,
laid bare.

Every part of rCommerce is inspectable and typed — from the checkout state machine to the request lifecycle to the hook points you extend. Here's how it fits together.

What's in the box

A complete commerce core.

Not a starter kit you finish yourself — the primitives a real store runs on, all first-class and all in the one binary.

01
Selling
Catalog & variants

Options, variant matrices, per-variant price & media.

Cart & promotions

Server-authoritative carts, discounts, gift cards.

Checkout state machine

Deterministic flow the client can't corrupt.

Digital & subscriptions

Downloads, licenses, and recurring billing.

02
Operating
Inventory & reservations

Multi-location stock with atomic guarantees.

Orders & fulfillment

Splits, partial shipments, and status hooks.

Payments & tax

Pluggable providers and tax strategies in config.

Refunds & disputes

Idempotent reversals with a full audit trail.

03
Building
REST API

Versioned HTTP API with JWT auth and API keys.

Typed plugin hooks

Extend the engine in Rust without forking it.

Webhooks & events

Signed, retried, on every state change.

Auth, roles & tokens

Scoped API tokens and granular staff permissions.

Checkout, as a state machine

Every order moves through defined states.

Transitions are validated on the server. An order can't skip payment or ship twice — the type system won't let it.

01
Cart
02
Reserved
03
Payment
04
Paid
05
Fulfilled
↳ declined → returns to Cart, stock released
↳ refunded → reversible from Paid onward
Request lifecycle

One core. Every event.

A request flows through the same typed core whether it arrives over the REST API — and every state change fans out as a signed event.

CLIENTS Next.js Astro iOS / Android POS
API REST WebSocket
rCOMMERCE CORE · Rust
Catalog Cart Orders Inventory Payments Tax Pricing Auth
DATA PostgreSQL
EVENTS →
webhook: order.paid email receipt analytics OpenTelemetry
Extensibility

Hook in. Don't fork.

Register typed handlers at defined points in the lifecycle. Your logic runs inside the engine with full type safety — and survives upgrades.

before_checkoutLoyalty points, fraud check
calc_priceB2B tiers, dynamic pricing
after_orderERP sync, print label
plugins/loyalty.rs
#[hook(after_order)]
async fn award_points(order: &Order) -> Result<()> {
    let pts = order.total.whole();
    loyalty::grant(order.customer, pts).await?;
    Ok(())
}
Plugins & integrations

Wire in the services you already use.

Payment gateways, shipping carriers, and caching plug in through the typed plugin system — switched on in config, no core changes.

Payments
Stripe Airwallex Alipay WeChat Pay
Shipping
ShipStation EasyPost
Performance
Redis cache WebSocket
<10ms
Fast under load

Sub-10ms responses and 10k+ concurrent connections. Async Rust — no fleet required.

0 CVEs
Secure by construction

Memory-safe core, parameterised queries, signed webhooks, scoped tokens.

100%
Observable

Structured logs, OpenTelemetry traces, and Prometheus metrics in the box.

See it running in five minutes.

Get started → See pricing