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

> ## Agent Instructions
> Weaverse component configuration uses `settings`. `inspector` is deprecated; never generate it.
> Weaverse Hydrogen themes use React Router v7: import from `react-router`, never `react-router-dom` or `@remix-run/*`.
> Before using any code sample, read `@weaverse/hydrogen` in the project's `package.json`: 6.x and 5.x import from different entries and use different type names, so code for one does not build on the other.
> `@weaverse/hydrogen` 6 (Shopify Hydrogen 2026.10 and later, the version these docs show) imports from `@weaverse/hydrogen/react-router` and uses `Weaverse*` types such as `WeaverseComponentProps`, `WeaverseComponentLoaderArgs` and `WeaverseComponentSchema`; the root `@weaverse/hydrogen` entry only exports `createSchema()`, data helpers and types.
> `@weaverse/hydrogen` 5.x (Hydrogen 2026.4 and earlier) imports everything from `@weaverse/hydrogen` and uses `HydrogenComponentProps`, `ComponentLoaderArgs` and `HydrogenComponentSchema`. On a 5.x project, convert samples to these names. Upgrade to 6 only when asked (`npx @weaverse/cli@latest migrate v6`, plus the Hydrogen 2026.10 upgrade). Do not mix major versions.
> Next.js themes use `@weaverse/hydrogen` 6.2.0 or later: import client and shared code from `@weaverse/hydrogen/next` and server-only code from `@weaverse/hydrogen/next/server`. `@weaverse/next` is deprecated; never install or import it.
> For live project data (pages, theme settings, translations), use the Weaverse MCP server: https://weaverse.io/docs/developer-tools/weaverse-mcp

# Why Weaverse for Hydrogen

> Technical advantages of using Weaverse as your visual page builder for Shopify Hydrogen storefronts.

# Why Weaverse for Hydrogen

If you're evaluating page builders or CMS solutions for a Shopify Hydrogen storefront, this page outlines the technical advantages that make Weaverse a purpose-built choice — and where alternatives might be a better fit.

## Component Loader Pattern

Every Weaverse section component can define its own `loader` function that runs **server-side** before the page is sent to the browser. This means each section independently fetches exactly the data it needs — no monolithic data layer, no prop-drilling from a top-level route.

**How it works:**

* Each section exports a `loader` that receives the Weaverse context and component settings
* The loader fetches data from Shopify's Storefront API, third-party services, or any external API
* Data is returned as `loaderData` props — fully server-rendered in the initial HTML
* Built-in `fetchWithCache` utility applies [Hydrogen caching strategies](https://shopify.dev/docs/storefronts/headless/hydrogen/caching) (`CacheShort`, `CacheLong`, `CacheCustom`) to every request

**What this enables:**

| Capability | Benefit |
| - | - |
| Per-section data fetching | Only fetch what each section needs — no over-fetching |
| Server-side rendering | Content is in the initial HTML — fast and SEO-friendly |
| Hydrogen caching built-in | Fine-grained cache control per data source |
| Parallel loading | Independent sections fetch data simultaneously |

> [!TIP]
>
> For implementation details and code examples, see the [Section Data Fetching](https://weaverse.io/docs/development-guide/data-fetching.md) guide.

## Server-Side Third-Party Data

Weaverse's loader pattern extends to **any** third-party service — product reviews, search engines, recommendation APIs, loyalty programs — all fetched server-side and rendered in the initial HTML response.

This is a significant architectural difference from traditional approaches:

| Approach | Data Fetching | SEO | Performance | API Key Security |
| - | - | - | - | - |
| **Weaverse (SSR loaders)** | Server-side via `fetchWithCache` | Content in initial HTML | No client-side waterfall | Keys stay on server |
| **Client-side JS injection** | Browser fetches after page load | Not indexed until JS runs | Layout shift, slower TTI | Keys exposed in bundle |
| **Custom middleware** | Separate server layer | Depends on implementation | Extra network hop | Secure, but more infra |

With Weaverse, a reviews integration such as Judge.me can render compact ratings or initial reviews server-side, then defer heavier review lists and pagination behind a Hydrogen resource route. Credentials stay on the server, while the storefront controls when and how much review data it loads.

> [!TIP]
>
> See the [Judge.me Reviews for Hydrogen](https://weaverse.io/docs/hydrogen-integrations/judgeme-reviews.md) walkthrough and the general [Third-Party Integration](https://weaverse.io/docs/features/third-party-integrations.md) guide.

## Infrastructure and Reliability

Weaverse is built on a multi-layered infrastructure designed for global availability and resilience.

### Store Hosting — Shopify Oxygen

Your Hydrogen storefront runs on [Shopify Oxygen](https://shopify.dev/docs/storefronts/headless/hydrogen/deployments), Shopify's edge hosting platform:

* **Global CDN** with edge locations worldwide
* **Automatic scaling** — handles traffic spikes without configuration
* **Shopify-backed SLA** — your store's availability is backed by Shopify's infrastructure

### Weaverse Platform — Multi-Region on Fly.io

The Weaverse platform (Studio, APIs, content delivery) runs on [Fly.io](https://fly.io) with servers in multiple regions:

* **US** (primary)
* **EU** (Europe)
* **Australia** (Asia-Pacific)

Requests are routed to the nearest region for minimal latency.

### Edge Caching — Cloudflare Workers

A [Cloudflare Workers](https://workers.cloudflare.com/) caching layer sits in front of Weaverse APIs:

* API responses cached at the edge for **up to 24 hours**
* Reduces origin load and improves response times globally
* **Resilience**: even if Weaverse origin servers experience downtime, your store continues serving cached content

> [!NOTE]
>
> Monitor platform status at [status.weaverse.io](https://status.weaverse.io/).

### Architecture Overview

```
[Browser] → [Shopify Oxygen CDN] → [Your Hydrogen App]
                                         ↓
                                   [Cloudflare Workers Cache]
                                         ↓
                                   [Weaverse API (Fly.io)]
                                   US | EU | Australia
```

## Shopify-Native Advantages

Because Weaverse builds **on top of** Shopify Hydrogen rather than replacing it, every native Shopify capability works out of the box — no rebuilding required.

| Capability | With Weaverse on Hydrogen | With a General CMS |
| - | - | - |
| **Checkout** | Shopify's native checkout — no rebuild | Must integrate separately |
| **B2B pricing** | Works via Storefront API context | Must build custom pricing layer |
| **Shopify Functions** | Discounts, shipping, payment customizations — native | Not available or requires custom integration |
| **Customer Accounts** | Hydrogen's built-in customer account API | Must build auth and account management |
| **Cart** | Shopify cart API — optimistic updates, line items | Must build cart from scratch |
| **Shopify Apps** | Compatible with the Shopify app ecosystem | Limited or no compatibility |
| **Markets & Localization** | Multi-currency, multi-language via Shopify Markets | Must build i18n and currency handling |

The key insight: with a general-purpose CMS, you gain content flexibility but **lose the entire Shopify commerce layer** — checkout, cart, B2B, customer accounts — and must rebuild it. With Weaverse, you get visual page building and content management while keeping everything Shopify provides.

## Content API

Weaverse provides a [Content API](https://weaverse.io/docs/content-api/overview.md) — a REST API that lets you read and update your page content, theme settings, and project data from **any application**.

**What this means:**

* Fetch Weaverse-managed content from a mobile app, a second storefront, or any custom frontend
* Content is not locked to Shopify's rendering layer
* Use the same visual editor (Weaverse Studio) to manage content that renders across platforms

```bash theme={null}
# Fetch page content from any application
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://studio.weaverse.io/api/v1/content/projects/PROJECT_ID/pages/INDEX/default"
```

This positions Weaverse as more than a Shopify page builder — it's a content platform that happens to have deep, native Shopify integration.

> [!TIP]
>
> Explore the full [Content API documentation](https://weaverse.io/docs/content-api/overview.md) for endpoints, authentication, and examples.

## When to Consider Alternatives

Weaverse is purpose-built for Shopify Hydrogen. But if your needs extend significantly beyond Shopify, other tools may be a better fit.

**Consider a general-purpose headless CMS (Sanity, Contentful, Strapi) when:**

* You need to manage content across **multiple platforms** that aren't Shopify (e.g., a custom React app, a mobile app, and a marketing site — all from one CMS)
* Your content model is highly complex and **not tied to e-commerce** (e.g., editorial publishing, documentation, multi-tenant content)
* You need **write APIs and workflows** for content creation (approval flows, scheduled publishing, granular roles)

**Choose Weaverse when:**

* You're building on **Shopify Hydrogen** and want to keep the full Shopify commerce stack
* You need a **visual page builder** that merchants can use without developer involvement
* You want **server-side data fetching** for third-party integrations without building custom middleware
* You need your store to run on **Shopify Oxygen** with Shopify-grade infrastructure
* You want a **single tool** that handles page building, content management, and Hydrogen component development

> [!WARNING]
>
> This isn't an either/or decision in all cases. Some teams use Weaverse for their Shopify storefront while using a separate CMS for non-Shopify content. The key question is: **where is your storefront running?** If it's Hydrogen, Weaverse is built for it.

## Next Steps

> [card] [5-Minute Quickstart](https://weaverse.io/docs/intro/quickstart.md)
>
> Get a Weaverse Hydrogen project running in minutes.

> [card] [Data Fetching Guide](https://weaverse.io/docs/development-guide/data-fetching.md)
>
> Learn the component loader pattern in depth.

> [card] [Third-Party Integrations](https://weaverse.io/docs/features/third-party-integrations.md)
>
> See real-world integration examples with reviews, analytics, and more.

> [card] [Content API](https://weaverse.io/docs/content-api/overview.md)
>
> Access your content from any application via REST API.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.