Skip to content
Cloud Merchant

Commerce operations, on one ledger

Every channel.
One ledger.

Cloud Merchant runs your marketplaces, storefront and wholesale from one system of record. Stock, orders, payments and margins that agree with each other, in a database that belongs to your shop alone.

Connects to

  • Amazon
  • eBay
  • Etsy
  • Walmart
  • Wayfair
  • TikTok Shop
  • Facebook
  • WooCommerce
  • and your own storefront

01Scatter

Eight channels. Eight versions of the truth.

Every marketplace keeps its own stock count, its own order format and its own idea of what sold. A spreadsheet reconciles them after the fact: after the oversell, after the refund, after the margin report was wrong.

  • Stock counts that drift between channels
  • Orders in eight shapes, sometimes delivered twice
  • Costs that change after the sale was booked

02Converge

Every order comes home.

Marketplace, storefront and wholesale orders land in one queue, in one shape. A webhook delivered twice is recorded once, because the stock an order moves carries a key built from what caused it, not from when the message arrived.

  • Idempotency keys built from order, line and reason
  • Inbound marketplace webhooks are default-deny
  • Marketplace-collected tax booked as the marketplace’s

03Record

One ledger. Written once.

Every stock movement is an entry, never an edit. On-hand is the sum of the ledger, not a number somebody typed. Payments work the same way, and the audit trail goes further: the database itself refuses to change an audit event.

  • Stock as append-only signed deltas, each with a reason
  • Payment totals derived from transactions, never stored
  • UPDATE, DELETE and TRUNCATE on audit events blocked by triggers

04Resolve

The last unit sells once.

Availability is checked and taken under a per-item lock, so two channels cannot both sell the unit you have. Checkout holds stock while the customer pays, and every channel reads the same available-to-sell figure, less the safety stock you set for it.

  • Tested: 20 simultaneous buyers, 5 units, exactly 5 orders
  • Checkout holds expire on their own, 30 minutes by default
  • Per-channel safety stock applied at read time

05Grow

Add a channel, not a problem.

When the ledger is the source of truth, a new marketplace, a new country or a wholesale account is one more lane out of the same core: priced in its own currency, taxed correctly, and measured on the cost you actually paid.

  • Country pricing: an explicit price beats a conversion
  • Inclusive tax extracted from the gross, never gross × rate
  • Margins use the cost at the time of sale

The platform

Everything the operation touches, on the same ground.

Selling, running and understanding the business are usually three systems that argue. Here they share one database, one ledger and one set of rules.

Sell

Sell everywhere, priced correctly.

One catalogue, published to every channel, with the price decided on the server every time.

Unified catalogue
Products, variants and collections defined once. Metafields cover what the schema does not, and stay private unless you expose them.
Marketplace channels
Amazon, eBay, Etsy, Walmart, Wayfair, TikTok Shop, Facebook and WooCommerce. Each shop’s channel keys are encrypted at rest with AES-256-GCM.
Headless storefront
A GraphQL Storefront API with carts, checkout and payment sessions. No input accepts a price; every line is priced from the catalogue.
Markets and currencies
Price by country and currency. An explicit price beats a conversion, and a shelf price only moves when someone records a new rate.
B2B and wholesale
Companies, locations and buyers with price lists, payment terms and credit limits. Credit is derived from unpaid orders, never typed in.

Run

Run the operation on one set of rules.

Stock, orders, delivery, purchasing and tax, all writing to the same ledger.

Inventory ledger
Append-only movements with a reason on each. Reservations hold stock during checkout, and a per-item lock stops two channels selling one unit.
Orders and fulfilment
Marketplace, storefront and on-account orders in one queue. Stock is committed when the order is created, and cancellations book it back.
Shipping zones
Zones with weight or order-value bands. A destination in no zone is refused at checkout, not quietly shipped for free.
Procurement
Purchase orders, goods receipts and three-way invoice matching. A 100 USD order against a 100 EUR invoice is a mismatch, and receipts book stock in.
Tax records
Inclusive tax extracted from the gross and rounded at the currency’s scale. Every order line keeps a tax record that is never rewritten.

Know

Know your numbers, and trust them.

Reports that say what they do not know, and a history that cannot be edited.

True margin
Gross margin from landed cost, including freight and duty, at the cost on the day of the sale. Unknown cost is excluded and counted, never zero.
Audit trail
Who changed what and when, across the admin. Audit events are append-only in the database, not just in the application.
Roles and permissions
Define roles for your team and grant permissions per area. Every change to a role is itself an audited event.
Privacy requests
GDPR access and erasure built in. Erasure keeps the orders your accountant is required to keep and tombstones the person.

For developers

An API that says no when it should.

A GraphQL Storefront API for shop fronts, a scoped Admin API for integrations, OAuth for apps and signed webhooks for what happens in between. Versioned by date, starting with 2026-01.

Build a cartGraphQL
# Storefront API, version 2026-01mutation AddToCart($lines: [CartLineInput!]!) {  cartCreate(lines: $lines) {    cart {      token        # a credential: keep it private      subtotal { amount currencyCode }      lines { quantity unitPrice { amount } }    }    userErrors { code message }  }}# CartLineInput has no price field.# Every line is priced from the catalogue.
Verify a webhookTypeScript
import { createHmac, timingSafeEqual } from "node:crypto";// Deliveries are signed over "{timestamp}.{body}".export function verify(req: Request, body: string, secret: string) {  const ts = Number(req.headers.get("x-inf-timestamp"));  const sig = req.headers.get("x-inf-signature") ?? "";  if (!ts || Math.abs(Date.now() / 1000 - ts) > 300) return false;  const expected = createHmac("sha256", secret)    .update(`${ts}.${body}`)    .digest("hex");  return sig.length === expected.length &&    timingSafeEqual(Buffer.from(sig), Buffer.from(expected));}
Scoped keys
Admin API keys are stored as hashes and carry explicit scopes. Write does not imply read, and a route that declares no scope is refused.
Apps with OAuth
Install flows use PKCE with S256 only, exact redirect matching and single-use codes. Merchants can deny individual scopes.
Signed webhooks
Retried with backoff and jitter, each with an event id that is stable across retries so you can deduplicate safely.
Bounded queries
Storefront queries are costed before they run: depth, a node budget for nested connections, and alias counts.

Security

Isolation you can point to.

Security claims are easy to write. These are properties of how the platform is built.

  • A database per shop

    Every shop runs on its own Postgres database. There is no shared table with a tenant column to forget, and a query with no shop in scope fails closed.

  • An audit trail the database defends

    Audit events are append-only below the application: triggers reject UPDATE, DELETE and TRUNCATE, so history cannot be quietly rewritten.

  • Credentials encrypted at rest

    Channel and payment keys are stored with AES-256-GCM and a fresh salt per credential, so a database dump or a misplaced backup is not a set of working keys.

  • Least privilege, everywhere

    Roles and permissions for staff, scoped keys for integrations, and install screens where a merchant can refuse any scope an app asks for.

  • Prices decided by the server

    No client names a price: not in the cart, not at checkout, not on a refund. Delivery is chosen by rate id and coupons by code, then priced server-side.

  • Privacy by design

    Access and erasure requests are verified before anything runs. Erasure keeps the financial record, removes the person, and audits counts rather than values.

Pricing

Every plan runs on its own database.

Isolation is not a premium feature. Choose by how many channels and products you run; moving up later is a change of plan, not a migration.

  • Pro

    For brands selling on a few channels and ready to stop reconciling them.

    $95/month

    Billed annually

    Request Pro
    • Up to 3 sales channels
    • 2,500 SKUs
    • Catalogue, inventory ledger and orders
    • Storefront API with checkout
    • Shipping zones and tax records
    • 5 team seats
    • Email support
  • Scale

    Most complete

    For operations across many channels, markets and suppliers.

    $279/month

    Billed annually

    Request Scale

    Everything in Pro, plus:

    • Unlimited sales channels
    • 25,000 SKUs
    • Markets, B2B and procurement
    • True-margin reporting
    • Roles, permissions and audit trail
    • Admin API, apps and webhooks
    • 20 team seats and priority support
  • Enterprise

    For high-volume and multi-region businesses with their own requirements.

    Custom

    Annual agreement

    Talk to us

    Everything in Scale, plus:

    • Unlimited SKUs and seats
    • Help migrating catalogue and history
    • Custom channel integrations
    • Architecture and security review
    • Annual contract and invoicing

No card is needed to request a shop. A person reviews every request before anything is built.

Questions

Straight answers.

Something not covered here? Ask us directly.

Is my data stored alongside other merchants’ data?

No. Every shop gets its own Postgres database, provisioned when the shop is created. There is no shared table that separates merchants by a column, and a request that does not resolve to a shop cannot reach any database.

Which sales channels does it connect to?

Amazon, eBay, Etsy, Walmart, Wayfair, TikTok Shop, Facebook and WooCommerce, plus your own storefront through the Storefront API and wholesale buyers through B2B accounts. All of them read and write the same inventory ledger.

What happens when two channels sell the last unit at the same moment?

One of them gets it. Availability is checked and taken under a per-item database lock, so the check and the sale cannot interleave. Checkout also holds stock while the customer pays, and the hold is released automatically if they do not.

Do I have to use your storefront?

There is no bundled storefront to be locked into. Cloud Merchant is headless: a shop front you build, or one an agency or app builds for you, talks to the GraphQL Storefront API, and reads your brand colours and type from it.

How is margin calculated?

From landed cost, meaning purchase price plus freight, duty and other charges allocated from the purchase order, taken at the cost that applied on the day of the sale. Sales with no recorded cost are excluded and counted, so the report tells you how much of revenue it can actually account for.

How is tax handled?

Tax at checkout is computed by Stripe Tax. Cloud Merchant records a tax line for every order line, extracts inclusive tax correctly from the gross, and books tax that a marketplace collected as the marketplace’s rather than as your liability.

Can we build our own integrations?

Yes. The Admin API uses scoped keys, apps install through OAuth with PKCE, and outbound webhooks are signed and retried with a stable event id. The API is versioned by date, so an integration keeps working as it evolves.

How quickly can we start?

Request a shop and a person reviews it, usually within one business day. Once it is approved, the shop is built automatically in a single run: its own database, schema, roles and owner account, with nothing for you to install.

Bring every channel home.

Tell us what you sell and where. A person reads every request, and once it is approved your shop, with its own database, roles and owner account, is built automatically.