> ## Documentation Index
> Fetch the complete documentation index at: https://docs.craveup.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Crave Cloud Overview

> How Crave Cloud connects franchise ordering, identity, loyalty, payments, operations, APIs, and open developer surfaces.

Crave Cloud is the franchise platform behind Crave.js. It gives restaurant brands one integration surface for digital ordering while letting each module be adopted independently, connected to systems the brand already trusts, or kept on the roadmap until the brand is ready.

For developers, that means Crave.js is not a standalone demo app. It is the storefront layer inside a broader cloud platform for restaurants with multiple locations, operators, payment accounts, loyalty providers, and guest touchpoints.

<Note>
  This page separates shipped surfaces from target product direction. Named bring-your-own providers are integration boundaries, not guaranteed prebuilt connectors.
</Note>

## The platform model

<CardGroup cols={3}>
  <Card title="Your world" icon="store">
    Guests, teams, apps, kiosks, franchisees, operators, developers, and restaurant locations.
  </Card>

  <Card title="Crave Cloud" icon="cloud">
    Business Manager foundations, Crave.js, API contracts, webhooks, integration health, readiness, and module configuration.
  </Card>

  <Card title="Connected franchise experience" icon="network">
    One customer experience across ordering, loyalty, payments, locations, and brand operations as each module is enabled.
  </Card>
</CardGroup>

## Ecosystem map

Read Crave Cloud left to right: your guest and operator channels connect once to Crave Cloud, Crave Cloud coordinates the modules, and the brand gets one connected franchise experience. Status labels show what is shipped today versus target direction.

```mermaid theme={null}
flowchart LR
  subgraph World["Your world"]
    Guests["Guests<br/>Order, pay, earn, redeem when loyalty is connected"]
    Teams["Your teams<br/>HQ, franchisees, operators, developers"]
    Channels["Digital channels<br/>Mobile app, web ordering, kiosk, custom storefronts"]
    Network["Restaurant network<br/>One brand, 1 to 500+ locations"]
    Guests --> Channels
    Teams --> Network
  end

  subgraph Cloud["Crave Cloud"]
    Connection["One connection<br/>Choose modules independently"]
    Manager["Business Manager<br/>Orgs, locations, roles, readiness, integrations<br/>Shipped foundations"]
    Surface["Crave.js surface<br/>SDK, REST, CLI, webhooks, UI components<br/>Shipped"]

    subgraph Modules["Choose modules independently"]
      Identity["Customer identity<br/>Target managed identity or BYO"]
      Ordering["Ordering<br/>Crave.js shipped"]
      Loyalty["Loyalty<br/>Engine exists; Cloud integration work"]
      Payments["Payments<br/>Stripe path shipped"]
    end

    Connection --> Surface
    Manager --> Surface
    Surface --> Identity
    Identity --> Ordering
    Identity --> Loyalty
    Ordering --> Payments
    Ordering --> Loyalty
  end

  subgraph Result["Connected franchise experience"]
    Customer["One customer across the brand<br/>Target"]
    DigitalOrdering["Flexible digital ordering<br/>Shipped for Crave.js path"]
    Rewards["Brand-wide loyalty<br/>Target"]
    Routing["Flexible payment routing<br/>Stripe path"]
    Ops["Centralized operations<br/>Foundations"]
    Keep["Keep what works<br/>Design"]
  end

  Channels --> Surface
  Network --> Surface
  Surface --> Customer
  Surface --> DigitalOrdering
  Loyalty --> Rewards
  Payments --> Routing
  Manager --> Ops
  Modules --> Keep
```

<Note>
  This map is intentionally simplified from the internal architecture diagram. Bring-your-own vendors are integration boundaries, not prebuilt connector promises. Confirm enablement per brand.
</Note>

## Core surfaces

| Surface               | What it does                                                                                                                                                                      |
| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Business Manager**  | Provides shipped foundations for organizations, locations, roles, readiness, integrations, analytics, and operational configuration.                                              |
| **Crave.js**          | Provides the shipped storefront developer surface: SDK, REST API patterns, CLI, webhooks, and React components for branded ordering experiences.                                  |
| **APIs and webhooks** | Give digital channels one integration surface for menus, carts, checkout, fulfillment, Stripe payments, analytics, and lifecycle events.                                          |
| **Modules**           | Let brands choose ordering, identity, loyalty, and payments independently. Some modules are shipped, some are target direction, and some require brand-specific integration work. |

## Choose modules independently

Crave Cloud is designed for gradual adoption. A brand can use Crave.js ordering while keeping an existing loyalty provider, or use the Stripe payment path while connecting an existing ordering platform. The goal is to replace only what needs replacing.

For loyalty, **Loyalty Interchange Protocol** means Crave's standard contract for balances, rewards, tiers, earning, redemption, refunds, and reversals across channels. The engine and contract exist; the Cloud-to-ordering integration layer is the product glue that makes it usable inside Crave Cloud.

| Module                | Current or managed path                                                                                                   | Bring-your-own path                                                                                | Status              |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ------------------- |
| **Customer identity** | Target Clerk-backed Crave Customer Identity. The storefront today still uses Stytch OTP.                                  | Existing identity provider using Auth0, Okta, Entra, Clerk, or OIDC patterns.                      | Target + BYO        |
| **Ordering**          | Crave.js menus, carts, checkout, fulfillment, analytics, Storefront SDK, REST API, and components.                        | Existing ordering platform, OMS, or custom storefront integration.                                 | Crave.js shipped    |
| **Loyalty**           | Loyalty Interchange Protocol contract and engine exist; Cloud-to-ordering integration work connects it to ordering flows. | Existing loyalty provider such as Punchh, Paytronix, Thanx, or Spendgo through integration work.   | Engine + integrate  |
| **Payments**          | Stripe Connect and Crave PaymentIntent flows.                                                                             | Existing gateway or processor integration such as Adyen, Braintree, Worldpay, or a custom gateway. | Stripe path shipped |

<Note>
  Bring-your-own providers are integration boundaries, not blanket availability promises. Use the current implementation guides and your Crave integration plan to confirm what is enabled for a specific brand.
</Note>

## Identity boundary

Crave Cloud keeps **guest identity** and **staff identity** separate.

* Guest identity powers storefront ordering, loyalty, rewards, and customer-facing channels.
* Staff identity powers Business Manager access, roles, franchise operations, and administrative workflows.
* Guests never become Business Manager organization members.
* Crave does not store guest passwords or issue guest auth tokens.
* Merchant keys and guest JWTs are not sent to Loyalty Interchange Protocol endpoints.

This separation matters for franchise brands because a customer can order across locations without becoming a staff user, and a franchise operator can manage locations without gaining access to guest accounts.

The target managed identity path is Clerk-backed Crave Customer Identity. The current storefront implementation still uses Stytch OTP, and bring-your-own identity providers are handled through brand-specific integration planning.

## Where Crave.js fits

Crave.js is the developer-facing ordering layer inside Crave Cloud:

* install `@craveup/storefront-sdk`
* scaffold storefronts with `npx craveup init`
* connect menus, modifiers, carts, checkout, fulfillment, Stripe payments, analytics, and webhooks
* use typed SDK helpers or direct REST calls
* customize UI components while keeping the restaurant ordering workflow intact

Crave.js is not the staff dashboard, the loyalty runtime, or a POS replacement. Those belong to other Crave Cloud surfaces or brand-specific integration work.

Start with [Build a Restaurant Ordering App in Minutes](/getting-started/introduction), then use this overview to understand how that storefront fits into Crave Cloud.