Headless Ecommerce API

Build custom storefronts with the QUANTM7 REST API. Ship faster with pre-shaped JSON, framework starter kits, and a managed backend you never have to host.

Build any storefront. We handle the backend.

QUANTM7 is a headless ecommerce API that gives developers everything they need to build custom storefronts. Products, collections, blog posts, menus, cart, and checkout are all available as clean REST endpoints that return pre-shaped JSON.

You pick the frontend framework. We handle the database, authentication, payments, and inventory. Your storefront stays fast because it pulls data at build time through static site generation (SSG) or incremental static regeneration (ISR).

Why developers choose QUANTM7

REST, not GraphQL

Every endpoint returns flat, predictable JSON. No query language to learn. No over-fetching or under-fetching to debug. One request, one response, every field you need.

curl https://api.quantm7.com/v1/products \
  -H "Authorization: Bearer q7_pk_your_key_here"

{
  "data": [
    {
      "title": "Classic Tee",
      "handle": "classic-tee",
      "variants": [
        {
          "title": "Small / Black",
          "price": 29.99,
          "in_stock": true
        }
      ],
      "images": [
        {
          "src": "https://cdn.quantm7.com/store/products/abc123.webp",
          "alt_text": "Classic Tee in black"
        }
      ]
    }
  ],
  "meta": { "page": 1, "per_page": 25, "total": 84 }
}

Works with any framework

Build with the tools you already know. QUANTM7 serves JSON. Your framework handles the rest.

Framework	Best for	Data strategy
Astro	Content-heavy stores, maximum performance	Static site generation at build time
Next.js	Hybrid static + dynamic pages	ISR with on-demand revalidation
Nuxt	Vue ecosystem stores	SSR or static generation
SvelteKit	Lightweight, fast storefronts	Server-side rendering
Remix	Nested layouts, progressive enhancement	Loader-based data fetching

Managed dashboard included

You get a full admin dashboard out of the box. No need to build product management, inventory tracking, order processing, or customer management from scratch.

Products with variants, images, SEO fields, and inventory tracking
Collections with manual curation or automatic rules
Orders with status tracking, refunds, and fulfilment
Customers with addresses, order history, and segments
Blog with categories, tags, and rich content sections
Menus with nested items and mega menu support
Analytics with sales, traffic, and conversion data

Two keys, clear boundaries

Generate a publishable key for your frontend code. It can only read data. Generate a secret key for your server. It can create carts and process checkouts. No complex OAuth flows. No token refresh logic.

q7_pk_abc123...  → Read products, collections, blog, menus
q7_sk_xyz789...  → Read everything + create carts + checkout

Stripe payments built in

Checkout returns a Stripe client_secret. Use Stripe's Payment Element on your frontend. We handle the payment intent, application fees, and order creation. You never touch raw payment logic.

// Your server
const res = await fetch('https://api.quantm7.com/v1/checkout', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer q7_sk_your_secret_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    cart_id: 'cart_abc123',
    email: 'customer@example.com',
    shipping: {
      name: 'Jane Smith',
      address1: '123 Main St',
      city: 'London',
      zip: 'SW1A 1AA',
      country_code: 'GB'
    }
  })
})

const { data } = await res.json()
// data.client_secret → pass to Stripe Payment Element
// data.total → 59.98

API endpoints

All endpoints live under https://api.quantm7.com/v1/.

Endpoint	Method	Description
`/v1/store`	GET	Store name, currency, and contact info
`/v1/products`	GET	Paginated product list with search and collection filtering
`/v1/products/{handle}`	GET	Single product with variants, images, and linked variants
`/v1/collections`	GET	All collections
`/v1/collections/{handle}`	GET	Collection with paginated products and sub-collections
`/v1/blog/posts`	GET	Paginated blog posts
`/v1/blog/posts/{handle}`	GET	Single blog post with content sections
`/v1/blog/categories`	GET	Blog categories
`/v1/pages/{handle}`	GET	Page with content sections
`/v1/menus/{handle}`	GET	Menu with nested item tree
`/v1/cart`	POST	Create a new cart
`/v1/cart/{id}`	GET	Get cart with items and totals
`/v1/cart/{id}/items`	POST	Add item to cart
`/v1/cart/{id}/items/{itemId}`	PUT/DELETE	Update quantity or remove item
`/v1/checkout`	POST	Create Stripe payment intent

See the full API reference for request and response details.

Quick start

1. Get your API keys

2. Fetch your products

curl https://api.quantm7.com/v1/products \
  -H "Authorization: Bearer q7_pk_your_key_here"

3. Build your page

Here is a minimal Astro example that lists products at build time:

---
// src/pages/products.astro
const res = await fetch('https://api.quantm7.com/v1/products', {
  headers: { 'Authorization': `Bearer ${import.meta.env.Q7_PUBLISHABLE_KEY}` }
})
const { data: products } = await res.json()
---

<html>
  <body>
    <h1>Products</h1>
    <ul>
      {products.map(product => (
        <li>
          <a href={`/products/${product.handle}`}>
            <img src={product.images[0]?.src} alt={product.images[0]?.alt_text} />
            <h2>{product.title}</h2>
            <p>${product.variants[0]?.price}</p>
          </a>
        </li>
      ))}
    </ul>
  </body>
</html>

This page builds once and ships as static HTML. No JavaScript runs in the browser. Load times are near instant.

4. Add a cart

Cart and checkout operations need a secret key and must run on your server (an API route or server function).

// src/pages/api/add-to-cart.ts
export async function POST({ request }) {
  const { cartId, variantId } = await request.json()

  const res = await fetch(
    `https://api.quantm7.com/v1/cart/${cartId}/items`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${import.meta.env.Q7_SECRET_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ variant_id: variantId, quantity: 1 })
    }
  )

  return new Response(JSON.stringify(await res.json()))
}

Pricing

Build for free. Pay when you go live.

	Sandbox	Pro	Enterprise
Price	Free forever	$49/month	$199/month
Products	100	5,000	Unlimited
API requests	25,000/month	250,000/month	2,500,000/month
Overages	Throttled	$12 per 100K	$6 per 100K
Dashboard	Full	Full	Full
Payments	Test mode	Live Stripe	Live Stripe
Support	Community	Email	Priority SLA

All plans include the full admin dashboard with product management, order processing, customer management, and analytics.

How QUANTM7 compares

Feature	QUANTM7	Shopify	Medusa	Commerce.js
API style	REST	GraphQL only	REST	REST
Managed hosting	Yes	Yes	Self-host or cloud	Yes
Admin dashboard	Included	Included	Self-host	Limited
Visual storefront	Optional (hybrid mode)	Yes (Liquid)	No	No
Open source	No	No	Yes	No
Free tier	Yes (100 products)	No	Yes (self-host)	Yes (limited)
Stripe built in	Yes	Shopify Payments	Plugin	Plugin

The key difference: QUANTM7 is the only platform that offers both a managed visual storefront AND a headless REST API from the same backend. Start headless. Switch to managed later. Or run both at the same time.

Next steps

Authentication to learn about API keys and CORS
Products API to start fetching product data
Cart and Checkout to build a purchase flow
Errors and Rate Limiting to handle edge cases

On this page