# Client Portfolios: Manage Multiple Sites as an Agency
Source: https://docs.schemagen.io/account/client-portfolios

Create isolated workspaces for each client, manage schemas and SDN settings per site, and hand off white-label deliverables from one Agency account.

Client portfolios give your agency a dedicated, isolated workspace for every client you manage. Each portfolio keeps that client's schemas, SDN configuration, and analytics completely separate from your other clients. You switch between clients from a single dashboard without logging out or switching accounts.

<Warning>
  Client portfolios are available on the **Agency plan only**. Upgrade from **Settings → Billing** to unlock this feature.
</Warning>

## What is isolated per client

When you create a client portfolio, SchemaGen provisions a separate environment for that client. The following data is scoped exclusively to that client:

* **Schema library** — saved schemas, drafts, and published schemas belong to that client's workspace only
* **SDN configuration** — the Client ID and SDK snippet are unique per client, so schema delivery targets only that client's site
* **Analytics** — schema performance data, GSC tracking, and audit history are siloed per client

Clients cannot see each other's data. If you have five clients, each one sees only their own schemas and analytics when you view their portfolio.

## How to add a new client

<Steps>
  <Step title="Go to the Clients page">
    From the main dashboard, click **Clients** in the sidebar. This opens your Client Portfolio overview.
  </Step>

  <Step title="Click Add Client">
    Click the **Add Client** button in the top-right corner of the Clients page.
  </Step>

  <Step title="Enter client details">
    Fill in the client's name and their website URL (for example, `https://example.com`). The name appears in your portfolio list and on any white-label exports.
  </Step>

  <Step title="Save the client">
    Click **Save** (or **Create**). SchemaGen creates the isolated workspace and generates a unique Client ID for that site.
  </Step>

  <Step title="Install the SDK on the client's site">
    Copy the SDK snippet that contains the client's unique Client ID and send it to the client's developer. Once installed, the SchemaGen SDK will deliver schemas to that domain.
  </Step>
</Steps>

## Switching between clients

From the **Clients** page, each client appears as a card showing their site name, domain, number of managed schemas, and last audit date. Click any card to enter that client's workspace. All views—schema builder, audit tool, analytics—update to show only that client's data.

To return to your agency overview, click **Back to Dashboard** at the top of the page.

## The Client ID

Every client portfolio has a unique **Client ID** generated by SchemaGen at creation time. You use this ID in the SDK snippet installed on the client's website. The SDK uses the Client ID to identify which schemas to fetch and inject on that domain.

To find a client's Client ID:

<Steps>
  <Step title="Open the client portfolio">
    Click the client's card from the **Clients** page.
  </Step>

  <Step title="Go to SDK or Settings">
    Look for the **SDK Setup** or **Settings** section within the client workspace. The Client ID and ready-to-copy script tag are displayed there.
  </Step>

  <Step title="Copy the snippet">
    Copy the full script tag and pass it to the developer responsible for the client's site. It only needs to be installed once.
  </Step>
</Steps>

<Note>
  Each client has a different Client ID. Using the wrong ID on a site will deliver another client's schemas. Double-check the ID matches the correct domain before handing it off.
</Note>

## White-label "Send to Dev" exports

Agency plan users can export any schema as a developer-ready package for client handoff. The export includes the final JSON-LD output formatted for direct implementation, without any SchemaGen branding.

To export a schema:

1. Open the schema you want to export from within the client's workspace.
2. Click **Send to Dev** (or the export option in the schema actions menu).
3. SchemaGen packages the JSON-LD into a clean, implementation-ready file you can attach to a ticket, email, or client report.

This is useful when a client's team wants to implement schema directly in their CMS or source code rather than relying on the SDN for delivery.

## Verified vs. pending SDK status

Each client card shows a status badge:

* **Verified** — the SDK snippet is installed and SchemaGen has confirmed it can reach the client's site. Schema delivery is active.
* **Pending SDK** — the snippet has not yet been detected on the client's domain. Send the SDK snippet to the client's developer to complete setup.

The status updates automatically once SchemaGen detects the snippet on the live site.


# Compare SchemaGen's Pricing Plans: Free, Pro, and Agency
Source: https://docs.schemagen.io/account/plans

Compare SchemaGen's Free, Pro ($29/mo), and Agency ($99/mo) plans, understand what's included in each tier, and upgrade or cancel anytime.

SchemaGen offers three plans designed for different stages of SEO work—from personal projects to full-service agency operations. All plans include JSON-LD validation and access to the schema builder. You can upgrade or cancel at any time from the dashboard with no contracts and no penalties.

<Tip>
  Start on the Free plan to explore the schema builder and validation tools. Upgrade to Pro when you need AI URL extraction or want to save more than 5 schemas.
</Tip>

## Plans at a glance

<CardGroup>
  <Card title="Free" icon="seedling">
    **\$0 / forever.** Build and validate schemas manually. Ideal for personal sites, learning structured data, or evaluating SchemaGen before committing. Includes 5 saved schemas and Google-supported schema types.
  </Card>

  <Card title="Pro" icon="bolt">
    **\$29 / month.** The full AI toolkit for solo SEOs and content professionals. Unlocks AI URL extraction, the AI copywriting agent, bulk generation, unlimited saved schemas, and the complete 800+ type Schema.org vocabulary.
  </Card>

  <Card title="Agency" icon="briefcase">
    **\$99 / month.** Everything in Pro, scaled for client work. Adds client portfolios, AI deep audit with PDF export, the site-wide audit tool, white-label deliverables, up to 5 team seats, and priority 24/7 support.
  </Card>
</CardGroup>

## Feature comparison

| Feature                                 | Free                  | Pro           | Agency         |
| --------------------------------------- | --------------------- | ------------- | -------------- |
| Full Schema.org vocabulary (800+ types) | Google-supported only | ✓             | ✓              |
| JSON-LD validation                      | ✓                     | ✓             | ✓              |
| Saved schemas                           | Up to 5               | Unlimited     | Unlimited      |
| AI URL extraction                       | —                     | ✓             | ✓              |
| AI copywriting agent                    | —                     | ✓             | ✓              |
| Bulk schema generation                  | —                     | 10 URLs / run | 100 URLs / run |
| AI deep audit + PDF export              | —                     | —             | ✓              |
| Client portfolios                       | —                     | —             | ✓              |
| Site-wide audit tool                    | —                     | —             | ✓              |
| Team seats                              | 1                     | 1             | Up to 5        |
| Priority 24/7 support                   | —                     | —             | ✓              |

## How to upgrade your plan

<Steps>
  <Step title="Open Settings">
    From any page in the dashboard, click your account avatar or the **Settings** link in the sidebar.
  </Step>

  <Step title="Go to Billing">
    Select the **Billing** tab inside Settings. You'll see your current plan and usage summary.
  </Step>

  <Step title="Click Upgrade">
    Choose **Pro** or **Agency** and click **Upgrade**. You'll be redirected to a secure Stripe checkout page.
  </Step>

  <Step title="Complete payment">
    Enter your payment details. After Stripe confirms the transaction, your new plan activates instantly—no waiting, no manual provisioning.
  </Step>
</Steps>

<Note>
  Payments are processed securely by Stripe. SchemaGen does not store your card details.
</Note>

## How to cancel your plan

<Steps>
  <Step title="Open Settings">
    Navigate to **Settings** from the dashboard.
  </Step>

  <Step title="Go to Billing">
    Select the **Billing** tab.
  </Step>

  <Step title="Cancel your subscription">
    Click **Cancel subscription**. Your plan remains active through the end of your current billing period. After that, your account reverts to the Free tier.
  </Step>
</Steps>

<Warning>
  Cancelling the Agency plan removes access to client portfolios, team seats, and all Agency-only features at the end of your billing period. Export any client deliverables or audit PDFs before cancelling.
</Warning>

## Billing details

* **Billing cycle:** Monthly only. Annual billing is not currently available.
* **Payment processor:** All transactions are handled by Stripe with full PCI compliance.
* **Access:** New features activate immediately after a successful payment.
* **Contracts:** None. Cancel anytime from the dashboard.

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How does AI URL extraction work?">
    Pro and Agency plans include an AI crawler. You paste any URL, and SchemaGen analyzes the page content—products, articles, FAQs, and more—then automatically maps it to the correct schema fields. This saves hours of manual data entry compared to filling out schema forms by hand.
  </Accordion>

  <Accordion title="Is there a limit on schemas in the Pro plan?">
    No. Once you upgrade to Pro, you can generate and save as many schemas as you need. There are no per-schema fees and no storage caps.
  </Accordion>

  <Accordion title="Can I cancel at any time?">
    Yes. All plans are month-to-month with no long-term contracts. Cancel directly from **Settings → Billing** with a single click. Your paid plan stays active until the end of the current billing period.
  </Accordion>

  <Accordion title="Do you offer annual discounts?">
    Currently SchemaGen only offers monthly billing to keep things straightforward. Annual pricing options are on the roadmap for a future release.
  </Accordion>

  <Accordion title="What is the site-wide audit tool?">
    The site-wide audit tool is exclusive to the Agency plan. Enter a domain and SchemaGen scans every page for structured data health, identifying missing schema opportunities, syntax errors, and validation failures. Results are presented in a per-URL report you can share directly with clients.
  </Accordion>
</AccordionGroup>


# Invite and Manage Team Members in Your Agency Workspace
Source: https://docs.schemagen.io/account/team-management

Add colleagues to your SchemaGen Agency workspace, view seat usage, manage pending invites, and remove members—all from the Team settings page.

Team management lets you share your SchemaGen workspace with colleagues so everyone on your agency can access schemas, client portfolios, and AI features under a single account. You do not need to purchase separate subscriptions for each person—your Agency plan covers the whole team.

<Warning>
  Team management is available on the **Agency plan only**. Free and Pro plans are single-user. To unlock team seats, upgrade your account to Agency from **Settings → Billing**.
</Warning>

## What team members can do

Every member you invite to your workspace has access to:

* All schemas saved in the workspace
* All client portfolios and their associated schemas, SDN configuration, and analytics
* AI features included in the Agency plan (URL extraction, copywriting agent, bulk generation, deep audit)
* The site-wide audit tool

The workspace owner retains administrative control, including the ability to invite and remove members.

## Seat limits

The Agency plan supports **up to 5 team seats**, including the workspace owner. Your current seat usage is displayed as a progress bar at the top of the **Team** page.

If you need more than 5 seats, contact SchemaGen sales about Enterprise options, which support unlimited members and custom roles.

## How to invite a team member

<Steps>
  <Step title="Open Settings">
    From the dashboard, click **Settings** in the sidebar.
  </Step>

  <Step title="Go to Team">
    Select the **Team** tab. You'll see a list of current workspace members and their status.
  </Step>

  <Step title="Enter an email address">
    In the **Invite Colleagues** panel on the right, type the email address of the person you want to add.
  </Step>

  <Step title="Send the invitation">
    Click **Send Invite**. SchemaGen sends an email invitation to that address immediately.
  </Step>
</Steps>

<Note>
  Invited members receive an email with a link to join your workspace. Their status shows as **Pending** until they accept the invitation and log in for the first time.
</Note>

## Viewing your team

The **Workspace Members** table on the Team page shows each member's email address, role (owner or member), status (active or pending), and the date they joined. Use this view to quickly check who has accepted their invitation and who still has a pending invite outstanding.

## How to remove a team member

<Steps>
  <Step title="Open the Team page">
    Navigate to **Settings → Team**.
  </Step>

  <Step title="Find the member">
    Locate the member you want to remove in the **Workspace Members** table.
  </Step>

  <Step title="Remove them">
    Click the remove action in the row for that member. Confirm the action when prompted. The member loses access to the workspace immediately.
  </Step>
</Steps>

<Note>
  Only the workspace owner can remove members. You cannot remove yourself as the owner.
</Note>

## What happens when you hit the 5-seat limit

When all 5 seats are occupied, the invite form is disabled and new invitations cannot be sent. A notice appears in the **Invite Colleagues** panel indicating that the workspace has reached maximum capacity. To add a new member, first remove an existing member to free up a seat.

If your team regularly exceeds 5 members, contact SchemaGen sales about an Enterprise plan with unlimited seats.


# SchemaGen API: Authentication and Access Level Guide
Source: https://docs.schemagen.io/api/authentication

Understand which SchemaGen API endpoints are public, which grant higher rate limits when authenticated, and which require a Pro or Agency account.

SchemaGen's API is designed to be accessible without a separate API key for most use cases. Authentication is tied to your SchemaGen account session, and the level of access you receive depends on whether you are logged in and what plan your account is on.

<Note>
  Most SchemaGen API endpoints do not require a separate API key. You do not need to generate or manage credentials — authentication is handled through your SchemaGen account session.
</Note>

## Public endpoints (no auth required)

The inject and embed APIs are fully public. They require only a `clientId` and a `url` query parameter, both of which are safe to use from client-side code and third-party platforms.

| Endpoint          | Auth required |
| ----------------- | ------------- |
| `GET /api/inject` | No            |
| `GET /api/embed`  | No            |

These endpoints are designed for use by the SchemaGen SDK and CMS integrations. They do not expose any account data.

## Endpoints with optional authentication

The generate and validate APIs accept requests from both authenticated and unauthenticated callers. The difference is in rate limits and usage tracking:

| Endpoint             | Guest behavior                              | Authenticated behavior                    |
| -------------------- | ------------------------------------------- | ----------------------------------------- |
| `POST /api/generate` | IP-based rate limit; no usage quota applied | Per-user rate limit; usage quota enforced |
| `POST /api/validate` | IP-based rate limit                         | IP-based rate limit (same as guest)       |

If you are building a server-side integration and want higher rate limits, make your requests from a session that is authenticated with a SchemaGen account.

## Endpoints that require authentication

The AI extraction endpoint requires an active session tied to a Pro or Agency plan account.

| Endpoint                      | Requirement                        |
| ----------------------------- | ---------------------------------- |
| `POST /api/generate-from-url` | Active session, Pro or Agency plan |

Calling this endpoint without a valid session returns a `403` response. Calling it as an authenticated user whose plan limit is exhausted also returns a `403` with error code `limit_reached`.

## How session-based authentication works

SchemaGen uses session-based authentication. You are considered authenticated when you are logged into the SchemaGen dashboard in the same browser or when your server-side request includes a valid session cookie issued by SchemaGen.

There is no separate API key to generate or rotate. If you need to make authenticated server-side API calls, your request must include the session cookie from an active SchemaGen login.

<Info>
  API key support for server-to-server integrations is not currently available. Authenticated server-side API calls require a session cookie from an active SchemaGen login.
</Info>

## Rate limiting by auth state

| Caller type        | Rate limit scope | Quota enforcement  |
| ------------------ | ---------------- | ------------------ |
| Guest (no session) | Per IP address   | No usage quota     |
| Authenticated user | Per user account | Monthly plan quota |

When the rate limit is exceeded, all endpoints return a `429` response regardless of auth state:

```json theme={null}
{
  "error": "Too many requests. Please wait a moment."
}
```


# GET /api/embed — Fetch Schemas as Renderable HTML
Source: https://docs.schemagen.io/api/embed

Retrieve published schemas as an HTML string of JSON-LD script tags, ready to drop into server-side templates, WordPress themes, or Shopify Liquid files.

The embed endpoint delivers published schemas as a ready-to-render HTML string instead of JSON. The response contains one or more `<script type="application/ld+json">` tags that you can insert directly into the `<head>` or `<body>` of any HTML page. This makes it the right choice for server-side rendering environments where you cannot run JavaScript to inject schemas at runtime.

<Note>
  This endpoint requires no authentication. It is a public CORS-enabled endpoint safe to call from any server environment.
</Note>

## When to use embed vs. inject

Use `/api/embed` when you are rendering pages on the server and want schemas included in the initial HTML response — for example, in a PHP template, a WordPress theme, a Shopify Liquid file, or an AMP page.

Use `/api/inject` (or the SchemaGen JavaScript SDK) when you are rendering pages in the browser and can inject schemas dynamically after the page loads.

| Scenario                                    | Recommended endpoint |
| ------------------------------------------- | -------------------- |
| PHP or server-side templates                | `/api/embed`         |
| WordPress theme or plugin                   | `/api/embed`         |
| Shopify Liquid templates                    | `/api/embed`         |
| AMP pages                                   | `/api/embed`         |
| JavaScript SPAs or static sites with JS SDK | `/api/inject`        |

## Endpoint

```
GET https://schemagen.io/api/embed
```

## Query parameters

<ParamField type="string">
  The UUID of your client site. You can find your Client ID in **Settings → Client** in the SchemaGen dashboard.
</ParamField>

<ParamField type="string">
  The absolute URL of the page you want to fetch schemas for. Must include the protocol (e.g., `https://example.com/products/widget`).
</ParamField>

## Response

A successful request returns `200` with a `Content-Type` of `text/html; charset=utf-8`. The body is an HTML string containing one `<script type="application/ld+json">` tag per published schema. If no schemas are published for the given URL, the body is an empty string.

### Example response body

```html theme={null}
<script type="application/ld+json">{"@context":"https://schema.org","@type":"Product","name":"Widget Pro","description":"A high-quality widget","offers":{"@type":"Offer","price":"49.99","priceCurrency":"USD"}}</script>
```

If multiple schemas are published for the URL, they are concatenated with no separator:

```html theme={null}
<script type="application/ld+json">{"@context":"https://schema.org","@type":"Product","name":"Widget Pro"}</script><script type="application/ld+json">{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[]}</script>
```

## Response headers

| Header                 | Description                                                                                                                   |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `X-Schemagen-Duration` | Server-side processing time in milliseconds.                                                                                  |
| `X-Schemagen-ID`       | A unique UUID identifying this request.                                                                                       |
| `Content-Type`         | Always `text/html; charset=utf-8`.                                                                                            |
| `Cache-Control`        | Responses are cached. Unlike `/api/inject`, embed responses may be served from cache to improve server rendering performance. |

## Code examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -G "https://schemagen.io/api/embed" \
    --data-urlencode "clientId=your-client-uuid" \
    --data-urlencode "url=https://example.com/products/widget"
  ```

  ```javascript Node.js (fetch) theme={null}
  const params = new URLSearchParams({
    clientId: 'your-client-uuid',
    url: 'https://example.com/products/widget',
  });

  const response = await fetch(`https://schemagen.io/api/embed?${params}`);
  const html = await response.text();

  // `html` is ready to insert into your server-rendered page
  ```

  ```php PHP theme={null}
  <?php
  $clientId = 'your-client-uuid';
  $url = 'https://example.com/products/widget';

  $apiUrl = 'https://schemagen.io/api/embed?' . http_build_query([
      'clientId' => $clientId,
      'url'      => $url,
  ]);

  $schemas = file_get_contents($apiUrl);

  // Output directly in your template <head>
  echo $schemas;
  ```
</CodeGroup>

### WordPress usage

Call the embed API in your theme's `functions.php` and output the result in the `<head>` using the `wp_head` action:

```php theme={null}
add_action('wp_head', function () {
    $clientId = 'your-client-uuid';
    $url      = get_permalink() ?: home_url($_SERVER['REQUEST_URI']);

    $apiUrl = add_query_arg(
        ['clientId' => $clientId, 'url' => rawurlencode($url)],
        'https://schemagen.io/api/embed'
    );

    $response = wp_remote_get($apiUrl);

    if (!is_wp_error($response)) {
        echo wp_remote_retrieve_body($response);
    }
});
```

## Error responses

When the request is invalid or an error occurs, the embed endpoint returns an empty body with the appropriate HTTP status code. It does not return a JSON error body.

| Status | Cause                                      |
| ------ | ------------------------------------------ |
| `400`  | `clientId` or `url` is missing or invalid. |
| `500`  | An unexpected server error occurred.       |

All error responses still include the `X-Schemagen-ID` header so you can trace the request.

<Tip>
  Because the embed endpoint returns an empty string when no schemas match the URL (rather than an error), you can safely output its response in every page template without a null check. Pages with no published schemas will simply have no extra output.
</Tip>


# POST /api/generate — Generate JSON-LD from a Schema Type
Source: https://docs.schemagen.io/api/generate

Generate valid JSON-LD by providing a Schema.org type name and field values. Supports guest and authenticated requests with different rate limit tiers.

The generate endpoint builds a valid JSON-LD object from a Schema.org type name and a set of field values you provide. You can call it without authentication as a guest, or as an authenticated user to apply generation against your account's usage quota and benefit from higher rate limits.

This endpoint is useful when you want to programmatically generate structured data — for example, as part of a content publishing pipeline or a custom schema tooling workflow.

## Endpoint

```
POST https://schemagen.io/api/generate
```

## Request body

<ParamField type="string">
  The Schema.org type name to generate (e.g., `Article`, `Product`, `LocalBusiness`, `FAQPage`). The value must match a type supported by SchemaGen. If the type is unrecognized, the API returns `400` with a list of supported types.
</ParamField>

<ParamField type="object">
  An object containing the field values for the schema. The accepted fields depend on the `type` you specify. Required fields for the given type must be present or the API returns a validation error.
</ParamField>

## Response

<ResponseField name="jsonLd" type="object">
  The generated JSON-LD object, ready to embed in a `<script type="application/ld+json">` tag. Includes `@context` set to `https://schema.org` and `@type` matching the requested type.
</ResponseField>

## Code examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST "https://schemagen.io/api/generate" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "Article",
      "data": {
        "headline": "How structured data improves SEO",
        "author": "Jane Smith",
        "datePublished": "2026-05-08",
        "url": "https://example.com/blog/structured-data-seo"
      }
    }'
  ```

  ```javascript JavaScript (fetch) theme={null}
  const response = await fetch('https://schemagen.io/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      type: 'Article',
      data: {
        headline: 'How structured data improves SEO',
        author: 'Jane Smith',
        datePublished: '2026-05-08',
        url: 'https://example.com/blog/structured-data-seo',
      },
    }),
  });

  const { jsonLd } = await response.json();
  console.log(jsonLd);
  ```
</CodeGroup>

## Example response

```json theme={null}
{
  "jsonLd": {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "How structured data improves SEO",
    "author": {
      "@type": "Person",
      "name": "Jane Smith"
    },
    "datePublished": "2026-05-08",
    "url": "https://example.com/blog/structured-data-seo"
  }
}
```

## Error responses

### 400 — invalid type

If you pass an unsupported `type`, the API returns `400` with a message listing valid types:

```json theme={null}
{
  "error": "Invalid or missing schema type. Supported types: Article, Product, LocalBusiness, ..."
}
```

### 400 — validation failed

If your `data` object is missing required fields or contains invalid values for the given type, the API returns `400` with a structured breakdown:

```json theme={null}
{
  "error": "Validation failed",
  "details": {
    "headline": {
      "_errors": ["Required"]
    }
  }
}
```

### 429 — rate limit exceeded

```json theme={null}
{
  "error": "Too many requests. Please wait a moment."
}
```

### 403 — usage limit reached

Authenticated users whose plan quota is exhausted receive a `403` with error code `limit_reached`:

```json theme={null}
{
  "error": "limit_reached"
}
```

<Info>
  Guest (unauthenticated) callers are not subject to usage quotas — only IP-based rate limits. If you need to call this endpoint at high volume from a server, authenticate your requests to get a per-user rate limit and quota tracking against your plan.
</Info>

<Warning>
  Usage is incremented only after a successful generation. Failed requests (400, 429, 403) do not count against your plan quota.
</Warning>


# GET /api/inject — Fetch Published Schemas as JSON
Source: https://docs.schemagen.io/api/inject

Retrieve published JSON-LD schemas for a specific page URL. The SchemaGen SDK calls this endpoint automatically; you can also call it directly.

The inject endpoint returns all published schemas for a given page as a structured JSON response. The SchemaGen JavaScript SDK calls this endpoint automatically when it loads on your site, but you can also call it directly if you want to build a custom schema delivery layer or inspect what schemas are active for a specific URL.

<Note>
  This endpoint requires no authentication. It is a public CORS-enabled endpoint safe to call from browser JavaScript or any server environment.
</Note>

## Endpoint

```
GET https://schemagen.io/api/inject
```

## Query parameters

<ParamField type="string">
  The UUID of your client site. You can find your Client ID in **Settings → Client** in the SchemaGen dashboard.
</ParamField>

<ParamField type="string">
  The absolute URL of the page you want to fetch schemas for. Must include the protocol (e.g., `https://example.com/blog/my-post`). SchemaGen uses this to match published schemas scoped to that specific page.
</ParamField>

## Response

A successful request returns `200` with a JSON body containing the schemas for the given page.

<ResponseField name="schemas" type="object[]">
  An array of raw JSON-LD objects — one for each published schema matching the requested URL. These are the objects you can embed directly in `<script type="application/ld+json">` tags.
</ResponseField>

<ResponseField name="items" type="object[]">
  An array of full schema delivery records. Each item includes the JSON-LD object along with metadata such as the schema name, type, and status.
</ResponseField>

<ResponseField name="meta" type="object">
  <Expandable title="properties">
    <ResponseField name="version" type="string">
      The inject API version. Current value: `1.2.0`.
    </ResponseField>

    <ResponseField name="requestId" type="string">
      A unique UUID identifying this request. Use this value when reporting issues to SchemaGen support.
    </ResponseField>

    <ResponseField name="serverTime" type="string">
      ISO 8601 timestamp of when the server processed the request.
    </ResponseField>
  </Expandable>
</ResponseField>

## Response headers

| Header                 | Description                                                                                                    |
| ---------------------- | -------------------------------------------------------------------------------------------------------------- |
| `X-Schemagen-Duration` | Server-side processing time in milliseconds (e.g., `42ms`).                                                    |
| `X-Schemagen-ID`       | The unique request ID, matching `meta.requestId` in the response body.                                         |
| `Cache-Control`        | Always `no-store, max-age=0`. Responses are never cached to ensure schemas reflect the latest published state. |

## Code examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -G "https://schemagen.io/api/inject" \
    --data-urlencode "clientId=your-client-uuid" \
    --data-urlencode "url=https://example.com/blog/my-post"
  ```

  ```javascript JavaScript (fetch) theme={null}
  const params = new URLSearchParams({
    clientId: 'your-client-uuid',
    url: 'https://example.com/blog/my-post',
  });

  const response = await fetch(`https://schemagen.io/api/inject?${params}`);
  const { schemas, items, meta } = await response.json();

  // Inject schemas into the page
  for (const schema of schemas) {
    const script = document.createElement('script');
    script.type = 'application/ld+json';
    script.textContent = JSON.stringify(schema);
    document.head.appendChild(script);
  }
  ```
</CodeGroup>

## Example response

```json theme={null}
{
  "schemas": [
    {
      "@context": "https://schema.org",
      "@type": "Article",
      "headline": "How to use structured data for SEO",
      "author": {
        "@type": "Person",
        "name": "Jane Smith"
      },
      "datePublished": "2026-01-15"
    }
  ],
  "items": [
    {
      "id": "sch_01abc123",
      "name": "Blog post schema",
      "schemaType": "Article",
      "pageUrl": "https://example.com/blog/my-post",
      "status": "published",
      "jsonLd": {
        "@context": "https://schema.org",
        "@type": "Article",
        "headline": "How to use structured data for SEO",
        "author": {
          "@type": "Person",
          "name": "Jane Smith"
        },
        "datePublished": "2026-01-15"
      }
    }
  ],
  "meta": {
    "version": "1.2.0",
    "requestId": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "serverTime": "2026-05-08T10:30:00.000Z"
  }
}
```

## Error responses

| Status | Cause                                      | Response body                                     |
| ------ | ------------------------------------------ | ------------------------------------------------- |
| `400`  | `clientId` or `url` is missing or invalid. | `{ "error": "Validation failed", "details": {} }` |
| `500`  | An unexpected server error occurred.       | `{ "error": "Internal Server Error" }`            |

<Warning>
  If `clientId` is not a valid UUID or `url` is not an absolute URL, the API returns `400` immediately without attempting schema lookup. Double-check both values in your request.
</Warning>


# SchemaGen API overview: base URL, errors, and rate limits
Source: https://docs.schemagen.io/api/overview

A reference overview of the SchemaGen API — base URL, available endpoints, error response format, rate limiting rules, and common HTTP status codes.

The SchemaGen API is a set of HTTP endpoints that power schema delivery, generation, and validation. You can call these endpoints directly to build custom integrations, server-side pipelines, or CMS plugins without relying on the SchemaGen JavaScript SDK.

## Base URL

All API requests use the following base URL:

```
https://schemagen.io
```

## Available endpoints

| Method | Path                     | Description                                                        | Auth required                         |
| ------ | ------------------------ | ------------------------------------------------------------------ | ------------------------------------- |
| `GET`  | `/api/inject`            | Fetch published schemas for a page as JSON                         | No                                    |
| `GET`  | `/api/embed`             | Fetch published schemas for a page as rendered HTML                | No                                    |
| `POST` | `/api/generate`          | Generate JSON-LD from a schema type and field data                 | No (higher limits when authenticated) |
| `POST` | `/api/validate`          | Validate existing JSON-LD against Schema.org and Google guidelines | No                                    |
| `POST` | `/api/generate-from-url` | Extract and generate JSON-LD from a live URL using AI              | Yes (Pro or Agency plan)              |

## Error format

All error responses return JSON with an `error` field and an optional `details` object.

```json theme={null}
{
  "error": "string describing the error",
  "details": {}
}
```

The `details` field appears on validation errors and contains a structured breakdown of what failed. It is omitted on rate limit, auth, and server errors.

## HTTP status codes

| Code  | Meaning                                                                                         |
| ----- | ----------------------------------------------------------------------------------------------- |
| `200` | Request succeeded.                                                                              |
| `400` | The request body or query parameters failed validation. Check the `details` field.              |
| `403` | Access denied. Either your plan limit has been reached or the requested resource is restricted. |
| `429` | Too many requests. You have exceeded the rate limit for this endpoint. Wait before retrying.    |
| `500` | An unexpected server error occurred.                                                            |
| `503` | A downstream service (such as the AI extraction engine) is temporarily unavailable.             |

## Rate limiting

SchemaGen applies rate limits at the endpoint level to ensure fair use.

* **Authenticated users** are rate-limited per user account and receive higher request allowances.
* **Unauthenticated users** are rate-limited per IP address and have lower allowances.

When you exceed the rate limit, the API returns a `429` response:

```json theme={null}
{
  "error": "Too many requests. Please wait a moment."
}
```

The `/api/validate` endpoint has its own independent rate limit separate from the generation endpoints.

<Note>
  Rate limits are applied on a fail-open basis: if the rate limit service is temporarily unavailable, requests are allowed through rather than blocked.
</Note>

## Usage limits

Authenticated users on paid plans have a monthly usage quota that applies to schema generation and AI extraction. When you reach your plan's limit, the API returns a `403` with error code `limit_reached`:

```json theme={null}
{
  "error": "limit_reached"
}
```

Guest (unauthenticated) users can call `/api/generate` without a usage limit, but are subject to IP-based rate limits.


# Validate API: check JSON-LD against Schema.org and Google
Source: https://docs.schemagen.io/api/validate

Check existing JSON-LD against Schema.org and Google Rich Result guidelines. Returns issues, warnings, SEO recommendations, and an auto-corrected schema.

The validate endpoint analyzes a JSON-LD object you already have and tells you whether it is valid, what types it detected, and what issues or improvements it found. It checks against the Schema.org specification, Google Rich Result eligibility guidelines, and general SEO recommendations. It also returns a corrected version of your schema when it can infer the right fix.

This endpoint is useful for auditing JSON-LD you sourced from third-party tools, validating schemas before publishing them to your SDN, or building validation into your own content pipeline.

## Endpoint

```
POST https://schemagen.io/api/validate
```

<Note>
  This endpoint does not require authentication. It is rate-limited per IP address using a separate limit from the generate endpoints.
</Note>

## Request body

<ParamField type="string">
  A JSON string representation of the JSON-LD object you want to validate. You must serialize your JSON-LD to a string before sending it. Pass the raw serialized string, not a nested JSON object.
</ParamField>

## Response

<ResponseField name="isValid" type="boolean">
  `true` if the JSON-LD passes all Schema.org and Google Rich Result checks with no blocking issues. `false` if one or more errors were found.
</ResponseField>

<ResponseField name="detectedTypes" type="string[]">
  An array of Schema.org type names detected in the JSON-LD (e.g., `["Article"]`, `["Product", "Offer"]`). Useful for confirming the validator interpreted your schema as intended.
</ResponseField>

<ResponseField name="issues" type="string[]">
  Blocking errors that make the schema invalid. Fix all items in this array before publishing. An empty array means no blocking errors were found.
</ResponseField>

<ResponseField name="warnings" type="string[]">
  Non-blocking issues that do not invalidate the schema but may affect rich result eligibility or data quality. Review these and address where possible.
</ResponseField>

<ResponseField name="schemaOrgIssues" type="string[]">
  Issues specific to the Schema.org specification, such as unrecognized properties or incorrect value types for the detected schema type. May be `undefined` if no Schema.org-specific issues were found.
</ResponseField>

<ResponseField name="googleRichResultWarnings" type="string[]">
  Warnings from Google Rich Result guidelines — for example, missing fields that Google requires for a schema type to qualify for rich results in Search. May be `undefined` if not applicable.
</ResponseField>

<ResponseField name="seoRecommendations" type="string[]">
  Optional best-practice suggestions for improving the schema's SEO value beyond minimum validity requirements. May be `undefined` if no recommendations apply.
</ResponseField>

<ResponseField name="correctedSchema" type="object | null">
  A corrected version of your JSON-LD with known fixable issues resolved, or `null` if no corrections could be inferred or the schema is already valid.
</ResponseField>

## Code examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST "https://schemagen.io/api/validate" \
    -H "Content-Type: application/json" \
    -d '{
      "jsonString": "{\"@context\":\"https://schema.org\",\"@type\":\"Article\",\"headline\":\"How structured data improves SEO\",\"author\":{\"@type\":\"Person\",\"name\":\"Jane Smith\"},\"datePublished\":\"2026-05-08\"}"
    }'
  ```

  ```javascript JavaScript (fetch) theme={null}
  const jsonLd = {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: 'How structured data improves SEO',
    author: {
      '@type': 'Person',
      name: 'Jane Smith',
    },
    datePublished: '2026-05-08',
  };

  const response = await fetch('https://schemagen.io/api/validate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ jsonString: JSON.stringify(jsonLd) }),
  });

  const result = await response.json();
  console.log(result.isValid);        // true or false
  console.log(result.issues);         // blocking errors
  console.log(result.correctedSchema); // fixed schema or null
  ```
</CodeGroup>

## Example response

```json theme={null}
{
  "isValid": false,
  "detectedTypes": ["Article"],
  "issues": [],
  "warnings": [
    "The 'image' property is missing. Google recommends including an image for Article rich results."
  ],
  "schemaOrgIssues": [],
  "googleRichResultWarnings": [
    "Missing recommended property: image"
  ],
  "seoRecommendations": [
    "Add a 'description' property to improve snippet quality in search results.",
    "Include 'publisher' with an Organization and logo for full Article rich result eligibility."
  ],
  "correctedSchema": {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "How structured data improves SEO",
    "author": {
      "@type": "Person",
      "name": "Jane Smith"
    },
    "datePublished": "2026-05-08"
  }
}
```

## Error responses

### 400 — invalid request body

If `jsonString` is missing or the request body itself cannot be parsed, the API returns `400`:

```json theme={null}
{
  "error": "Validation failed",
  "details": {
    "jsonString": {
      "_errors": ["Required"]
    }
  }
}
```

### 429 — rate limit exceeded

```json theme={null}
{
  "error": "Too many requests. Please try again later."
}
```

<Tip>
  Pass the `correctedSchema` value back to `/api/validate` to confirm the corrections resolved all issues before you publish the schema to your site.
</Tip>


# AI URL Extraction: Auto-Generate Schema from Any Page
Source: https://docs.schemagen.io/features/ai-extraction

Paste any URL and SchemaGen's AI pipeline crawls the page, maps its content to Schema.org, and pre-fills your schema form in seconds.

AI URL Extraction lets you generate a complete, pre-filled schema form from any live URL. Paste the address of a product page, article, business listing, or event, and SchemaGen's AI pipeline fetches the page, analyzes its content, and maps everything it finds to the correct Schema.org type and properties. You review the result, make any adjustments, and publish—no manual data entry required.

<Info>
  AI URL Extraction is available on **Pro** ($29/mo) and **Agency** ($99/mo) plans. Free plan users can use the manual [Schema Builder](/features/schema-builder) instead.
</Info>

## How to extract a schema from a URL

<Steps>
  <Step title="Open Generate from URL">
    In the dashboard, click **Generate from URL** in the left sidebar or from the **New Schema** menu. The extraction interface opens with a URL input field.
  </Step>

  <Step title="Paste your URL">
    Enter the full URL of the page you want to extract schema from—including the `https://` prefix. For example: `https://example.com/products/trail-running-shoes`.
  </Step>

  <Step title="Start extraction">
    Click **Extract**. SchemaGen sends the URL through the AI pipeline: the page is crawled and rendered, its content is analyzed by Claude AI, and the relevant data is mapped to Schema.org fields. This typically takes 5–15 seconds.
  </Step>

  <Step title="Review the pre-filled form">
    When extraction completes, the Schema Builder opens with every detected field pre-filled. The AI selects the most appropriate schema type for the page and populates properties like name, description, price, images, author, and dates from the page content.
  </Step>

  <Step title="Adjust and correct">
    Review every field before saving. AI extraction is accurate but not infallible—check that names, prices, dates, and URLs are correct. Add any missing required or recommended fields that the AI did not detect.
  </Step>

  <Step title="Save as draft or publish">
    When the form looks right, click **Save as Draft** to review it further, or **Publish** to deploy it to the SDN immediately.
  </Step>
</Steps>

<Tip>
  Always review the extracted schema before publishing. The AI reads visible page content, so it works best on pages with clear, structured text. Verify that required fields (marked with a red asterisk) are filled and that factual details like prices and dates match your page exactly.
</Tip>

## Pages that work best

AI extraction produces the highest-quality results for pages with rich, structured content on them.

<CardGroup>
  <Card title="Product pages" icon="bag-shopping">
    E-commerce product pages with names, prices, descriptions, images, SKUs, and availability status extract with high accuracy.
  </Card>

  <Card title="Articles and blog posts" icon="newspaper">
    News articles and blog posts with bylines, publish dates, headlines, and body copy map cleanly to `Article` and `NewsArticle` types.
  </Card>

  <Card title="Local business listings" icon="location-dot">
    Pages with business name, address, phone number, hours, and service area work well for `LocalBusiness` and its subtypes.
  </Card>

  <Card title="Events" icon="calendar">
    Event pages with names, dates, locations, ticket links, and organizer information populate `Event` schemas reliably.
  </Card>
</CardGroup>

Pages with very little visible text, heavy JavaScript rendering requirements, or paywalled content may extract with fewer populated fields. For those pages, use the manual [Schema Builder](/features/schema-builder) and fill in the fields directly.

## The AI copywriting agent

During extraction, SchemaGen also runs its AI copywriting agent on the detected content. The agent rewrites descriptions and names to be more concise, better formatted, and optimized for how search engines read schema values.

For example, if a product page has a description like "Buy our trail running shoes online today—free shipping on orders over \$50!", the agent trims it to a factual description that works better as structured data: "Lightweight trail running shoes with reinforced toe cap and Vibram outsole."

You can see the AI-enhanced version in the pre-filled form. If you prefer the original page text, paste it back in manually before saving.

## Error states

If extraction fails, SchemaGen returns one of these errors:

<AccordionGroup>
  <Accordion title="extraction_timeout — page took too long to load">
    The page did not respond within the allowed window. This happens on slow servers, pages with long redirect chains, or pages that block automated crawlers with JavaScript challenges. Wait a moment and try again. If it consistently times out, use the manual Schema Builder instead.
  </Accordion>

  <Accordion title="high_demand — extraction service is busy">
    The AI pipeline is under heavy load and cannot accept new requests right now. This is temporary. Wait a few minutes and try again.
  </Accordion>

  <Accordion title="site_unsupported — site blocks automated access">
    The page actively blocks crawlers (for example, via robot directives or bot detection). SchemaGen cannot access this page automatically. Use the manual [Schema Builder](/features/schema-builder) and fill in the fields from the page yourself.
  </Accordion>

  <Accordion title="ai_unavailable — AI returned an empty response">
    The AI analysis step completed but returned no usable data. This is rare and typically resolves on retry. If it persists, the page may have too little extractable text content for the AI to work with.
  </Accordion>
</AccordionGroup>

## Usage quota

<Warning>
  Every AI URL Extraction counts toward your monthly AI generation quota. Pro plan users have a monthly limit on AI generations. Agency plan users have a higher limit. If you reach your quota, the extraction feature is unavailable until your quota resets at the start of your next billing cycle. Manual schema generation via the Schema Builder does not count toward this quota.
</Warning>

You can check your current usage at any time from **Account → Usage** in the dashboard.


# Site-wide Audit Tool: Schema Health Across Your Domain
Source: https://docs.schemagen.io/features/audit-tool

Scan every page of a domain for structured data gaps, syntax errors, and missed Rich Result opportunities, then export a PDF report for clients.

The Site-wide Audit Tool scans every page of a domain and produces a structured data health report for the entire site. Instead of checking pages one by one, you enter a domain, start the audit, and get back a per-URL breakdown showing what schema is present, what's missing, where errors exist, and which pages represent the biggest opportunities for structured data improvement.

<Warning>
  The Site-wide Audit Tool is an **Agency plan** feature (\$99/mo). Single-page auditing is available to all users as a free tool from the dashboard. To unlock full site audits with PDF export, upgrade to the Agency plan.
</Warning>

## How to run a site audit

<Steps>
  <Step title="Open the Audit Tool">
    From the dashboard, click **Audit** in the left sidebar. The audit interface loads with a URL input and a mode selector.
  </Step>

  <Step title="Enter your sitemap URL">
    Paste the sitemap URL for the domain you want to audit—for example, `https://example.com/sitemap.xml`. SchemaGen parses the sitemap XML, extracts all page URLs, and queues them for analysis. The audit covers up to 20 URLs from the sitemap per run.

    <Tip>
      Use your root sitemap if your site has multiple sitemaps. If your site uses a sitemap index file, link to the main index and SchemaGen will follow the references. For the most complete picture, make sure your sitemap is up to date before running an audit.
    </Tip>
  </Step>

  <Step title="Start the audit">
    Click **Run Audit**. SchemaGen begins crawling and analyzing each URL in the queue. The audit runs page by page; you can see progress update in real time as each URL completes.
  </Step>

  <Step title="Review the per-URL report">
    When the audit finishes, the results appear as a table with one row per audited URL. Each row shows the page URL, its structured data health score, detected schema types, issues found, and AI-generated recommendations.
  </Step>

  <Step title="Drill into individual pages">
    Click any URL in the results table to open its detailed page report. Here you can see every schema issue on that page, the specific fields causing problems, and suggested fixes. You can also launch the Schema Builder from this view, pre-populated with the corrected schema for that page.
  </Step>

  <Step title="Export the PDF report">
    Click **Export PDF** to generate a shareable report covering the entire audit. The PDF includes the per-URL health scores, issue summaries, and AI recommendations formatted for client presentation.
  </Step>
</Steps>

## What the audit report covers

Each page in the audit results includes the following information:

<CardGroup>
  <Card title="Schema health score" icon="gauge">
    A score for each page reflecting how complete and error-free its structured data is. Pages with no schema score lowest; pages with valid, Google-eligible schema score highest.
  </Card>

  <Card title="Detected schema types" icon="tags">
    Every `@type` found on the page, including schemas already deployed through SchemaGen and any existing JSON-LD in the page source.
  </Card>

  <Card title="Syntax errors" icon="triangle-exclamation">
    Structural problems with existing schema markup that prevent search engines from reading it correctly—missing required fields, invalid property types, malformed JSON.
  </Card>

  <Card title="Missing schema opportunities" icon="lightbulb">
    Pages where structured data could be added but isn't. The audit identifies the schema type that would be most appropriate for each page based on its content.
  </Card>
</CardGroup>

## AI deep audit

For each page, the audit also runs an AI deep audit that generates a plain-language recommendation specific to that page's content and existing schema state. This goes beyond generic validation rules to provide context-aware guidance—for example, identifying that a product page has a `Product` schema but is missing `aggregateRating` despite having visible review content, or that a FAQ section is present in the page body but has no corresponding `FAQPage` schema.

These recommendations are written in language your clients can understand, making them useful to include directly in the exported PDF report.

## PDF export and client deliverables

The PDF report is designed to be shared with clients or stakeholders who don't have access to the SchemaGen dashboard. It includes:

* An executive summary with overall domain schema health
* A page-by-page breakdown with scores and top issues
* AI-generated recommendations per page
* Your agency branding (with white-label settings configured in **Account → White Label**)

To export, click **Export PDF** from the audit results view. The file generates and downloads automatically. Agency plans include white-label deliverables, meaning you can replace SchemaGen's branding with your own agency name and logo in the report.

## Audit limitations and error states

* **Site blocked:** If the domain blocks automated crawlers, the audit cannot retrieve page content. The affected URLs appear as failed in the results table with a `site_unsupported` error. For sites you manage, check your `robots.txt` to ensure SchemaGen's crawler is not disallowed.
* **Timeout:** Pages that are very slow to load may time out during crawling. These appear as failed results. Try re-running the audit during off-peak hours if a significant number of pages are timing out.
* **20-page limit per run:** Each audit run processes up to 20 URLs from the sitemap. For large sites, prioritize by submitting a focused sitemap (for example, just your product pages or blog posts) for targeted audits.


# Bulk Generation: Generate Schemas for Multiple URLs
Source: https://docs.schemagen.io/features/bulk-generation

Submit a list of URLs or a sitemap and SchemaGen's AI generates schemas for every page simultaneously, processed as a background job.

Bulk Generation lets you create schemas for many pages at once instead of one URL at a time. Submit a list of URLs or point SchemaGen at a sitemap, start the job, and the AI pipeline processes every page in parallel as a background task. When the job finishes, you review the results, approve the schemas you want to publish, and deploy them all in one action.

<Info>
  Bulk Generation is available on **Pro** ($29/mo) and **Agency** ($99/mo) plans. Free plan users can generate schemas individually using the [Schema Builder](/features/schema-builder) or [AI URL Extraction](/features/ai-extraction).
</Info>

## URL limits by plan

| Plan   | URLs per bulk run | Sitemap import |
| ------ | ----------------- | -------------- |
| Free   | Not available     | —              |
| Pro    | Up to 10 URLs     | Yes            |
| Agency | Up to 100 URLs    | Yes            |

If you submit more URLs than your plan allows, the job is rejected before it starts and you'll see a clear error message showing your limit.

## How to run a bulk generation job

<Steps>
  <Step title="Open Bulk Generation">
    From the dashboard, click **Bulk Generate** in the left sidebar. The bulk job form opens with two input methods: a URL list and a sitemap URL field.
  </Step>

  <Step title="Add your URLs">
    Choose one of two methods:

    **Manual URL list** — Paste or type your URLs into the text area, one URL per line. Pro accounts can enter up to 10; Agency accounts up to 100.

    **Sitemap import** — Paste the URL of your sitemap XML (for example, `https://example.com/sitemap.xml`) into the sitemap field and click **Import**. SchemaGen parses the sitemap, extracts all `<loc>` entries, and pre-fills the URL list. You can then remove any URLs you don't want to include before starting the job.
  </Step>

  <Step title="Start the job">
    Click **Start Bulk Job**. SchemaGen validates your URL list against your plan limits, creates a job record, and starts processing your URLs in the background. You receive a job ID immediately—the page does not wait for the job to complete before responding.
  </Step>

  <Step title="Monitor job progress">
    The bulk job view shows live progress: how many URLs have been processed versus the total, and which individual URLs have completed, are in progress, or have failed. The page polls for updates automatically. You can leave and return to the dashboard at any time—the job continues running in the background.
  </Step>

  <Step title="Review the results">
    When the job status changes to **Completed**, each URL shows its extracted schema, detected type, and any Rich Result warnings. Click any result to open the full pre-filled schema form, where you can review fields, make adjustments, and confirm before saving.
  </Step>

  <Step title="Publish approved schemas">
    From the results view, select the schemas you want to deploy and click **Publish Selected**. All selected schemas are saved and pushed to the SDN simultaneously. Schemas you don't publish are saved as drafts you can return to later.
  </Step>
</Steps>

## Job statuses

Each bulk job moves through the following statuses:

* **processing** — the job is actively running. URLs are being crawled and analyzed in batches of three at a time.
* **completed** — all URLs have been processed. Individual results may show `success` or `error` per URL.
* **error** (per URL) — a single URL failed within an otherwise successful job. The remaining URLs still complete. The error reason is shown alongside the failed URL.

If a URL fails (for example, due to a timeout or an unsupported site), it does not stop the rest of the job. SchemaGen retries each URL up to two times before marking it as failed.

## Reviewing and approving bulk results

Not every extracted schema requires the same level of review. Use the results table to quickly scan for issues:

* URLs with **warnings** have Rich Result eligibility issues that you should address before publishing. Click the URL to open the schema and fix the flagged fields.
* URLs marked **error** could not be processed. Open those pages individually in [AI URL Extraction](/features/ai-extraction) or fill them in manually with the Schema Builder.
* URLs with a clean **success** status and no warnings are ready to publish as-is.

<Note>
  Every URL processed in a bulk job counts toward your monthly AI generation quota—including URLs that fail after extraction starts. A 10-URL bulk job on a Pro plan uses 10 AI generation credits. Monitor your usage at **Account → Usage**.
</Note>


# Schema Builder: Create JSON-LD Without Writing Code
Source: https://docs.schemagen.io/features/schema-builder

Build and publish JSON-LD structured data for any page using SchemaGen's visual form-based editor—covering 800+ Schema.org types, no code required.

The Schema Builder is SchemaGen's visual editor for creating JSON-LD structured data by hand. Instead of writing markup directly, you fill in a guided form that maps to the full Schema.org vocabulary. When you save, SchemaGen generates valid JSON-LD and makes it ready to deploy through the Schema Delivery Network.

## Open the Schema Builder

From the dashboard, click **New Schema** in the top-right corner. This opens the Schema Builder and takes you directly to the type selector.

<Info>
  The Schema Builder is available on all plans. Free plan users can choose from Google-supported schema types only (Article, Product, FAQ, HowTo, LocalBusiness, Event, Recipe, Review, and a few others). Pro and Agency plans unlock the full Schema.org vocabulary—800+ types across every category.
</Info>

## Select a schema type

The type selector is a searchable dropdown. Type any keyword—"product", "event", "software", "job"—and matching types appear instantly. Each result shows the Schema.org type name, its parent type hierarchy, and a brief description.

<Tip>
  If you're unsure which type fits your page, search by what the page is about rather than a technical term. Searching "recipe" finds `Recipe`, searching "restaurant" finds `Restaurant` and its related subtypes like `BarOrPub` or `FastFoodRestaurant`.
</Tip>

Once you select a type, the form loads all its fields.

## Fill in the form fields

Each field in the Schema Builder is labeled with its Schema.org property name and a plain-English label. Fields are grouped into three categories:

<CardGroup>
  <Card title="Required" icon="circle-exclamation">
    Fields that must be filled in for valid schema. Marked with a red asterisk. Saving without these fields will fail validation.
  </Card>

  <Card title="Recommended" icon="circle-check">
    Fields that are not required by Schema.org but are expected by Google for Rich Result eligibility. Filling these in improves your chances of enhanced search appearances.
  </Card>

  <Card title="Optional" icon="circle">
    Additional properties that provide more context. These can improve schema quality but are not evaluated by Google's Rich Result guidelines.
  </Card>
</CardGroup>

Field types vary by property. Text fields accept plain strings, URL fields validate that you've entered a proper URL, date fields use a date picker, and array fields let you add multiple items (such as a list of FAQPage entries or multiple images).

Each field includes a **help text** tooltip that describes what the property means in Schema.org terms and what format the value should take.

## Assign the schema to a page URL

Before saving, enter the **Page URL** this schema belongs to. This is the full URL of the page where you want the JSON-LD to appear when published through the SDN (for example, `https://example.com/products/hiking-boots`).

You can save a schema without a page URL, but it cannot be published to the SDN until a URL is assigned. You can add or update the URL later from the schema detail view.

## Save as draft or publish directly

When you're ready, use the action buttons at the bottom of the form:

* **Save as Draft** — saves the schema to your account in `draft` status. It is not delivered to your website. Use this when you want to review or validate before going live.
* **Publish** — saves and immediately pushes the schema to the SDN. The JSON-LD becomes active on the assigned page URL within seconds.

<Warning>
  Publishing is instant. If your page URL is already receiving traffic, the schema goes live as soon as you click **Publish**. Use **Save as Draft** first if you want to validate the output before deploying.
</Warning>

## The Draft → Validate → Publish workflow

For important schemas—product pages, article templates, local business listings—the recommended workflow is:

<Steps>
  <Step title="Build and save as draft">
    Fill in the form and click **Save as Draft**. The schema is saved with `draft` status and is not yet active on your site.
  </Step>

  <Step title="Open the validator">
    From the schema detail view, click **Validate**. SchemaGen runs the schema against both Schema.org requirements and Google Rich Result guidelines and returns a full report.
  </Step>

  <Step title="Fix any issues">
    Review errors and warnings from the validation report. Return to the editor to correct missing required fields or fix property format issues. See the [Validation](/features/validation) page for a full breakdown of what the validator checks.
  </Step>

  <Step title="Publish">
    Once validation passes (or you've addressed the issues you care about), click **Publish**. The schema status changes to `published` and goes live on the SDN.
  </Step>
</Steps>

## Manage your schemas

All your saved schemas appear in the **Schemas** list on the dashboard. Each schema shows its name, type, assigned URL, status badge (`draft`, `published`, or `paused`), and the date it was last updated.

From the schema list or the schema detail view, you can:

* **Edit** — reopen the builder form pre-filled with the schema's current values. Editing a published schema does not take the current version offline; changes are applied when you save and re-publish.
* **Pause** — changes status to `paused`. The schema stops being delivered by the SDN, but the record and all its data are preserved. Use this to temporarily disable a schema without deleting it.
* **Resume** — returns a paused schema to `published` status and reactivates SDN delivery.
* **Delete** — permanently removes the schema. This cannot be undone.

<Note>
  Free plan accounts can save up to 5 schemas. Pro and Agency plans have no schema limit. If you're on the Free plan and reach the limit, you must delete an existing schema before creating a new one, or upgrade to Pro.
</Note>


# Validate JSON-LD Against Schema.org and Google Standards
Source: https://docs.schemagen.io/features/validation

Check any JSON-LD against Schema.org specifications and Google Rich Result guidelines, with automatic correction suggestions and SEO recommendations.

SchemaGen's validator checks your JSON-LD against two separate standards at once: the Schema.org specification itself, and Google's Rich Result requirements. These are not the same thing—a schema can be perfectly valid Schema.org and still fail to qualify for a Rich Result. The validator reports on both so you know exactly what to fix and why.

Validation is available on all plans, including Free.

## What the validator checks

**Schema.org compliance** confirms that your JSON-LD is structurally correct. This includes whether required properties are present, whether property values match their expected types (a URL field should be a URL, a date field should follow ISO 8601, and so on), and whether the overall structure matches the Schema.org definition for that type.

**Google Rich Result eligibility** checks whether your schema meets the additional requirements that Google imposes on specific types for enhanced search appearances—featured snippets, star ratings, price information in search results, and similar rich features. Google's requirements are a subset of Schema.org but often stricter about which specific fields must be present.

## Two ways to validate

<Tabs>
  <Tab title="From the dashboard editor">
    Open any saved schema from your **Schemas** list and click **Validate** in the schema detail toolbar. The validator runs immediately and displays the full result below the schema preview. This is the fastest way to validate schemas you're working on in SchemaGen.

    You can also click **Validate** directly from the Schema Builder before saving, to check your work as you fill in the form.
  </Tab>

  <Tab title="Via the API">
    Send any JSON-LD string to the `/api/validate` endpoint. This is useful if you want to validate schemas you built outside of SchemaGen, or if you want to check existing markup on your site before importing it.

    ```bash theme={null}
    curl --request POST \
      --url https://schemagen.io/api/validate \
      --header 'Content-Type: application/json' \
      --data '{ "jsonString": "{\"@context\":\"https://schema.org\",\"@type\":\"Product\",...}" }'
    ```

    The response returns the same full validation result object as the dashboard.
  </Tab>
</Tabs>

## Understanding the validation result

A validation result contains several distinct sections:

| Field                      | What it tells you                                                        |
| -------------------------- | ------------------------------------------------------------------------ |
| `isValid`                  | Whether the schema passes all required checks for its detected type      |
| `detectedTypes`            | The `@type` values found in the schema (may be multiple if nested)       |
| `issues`                   | Hard errors that make the schema invalid—these must be fixed             |
| `warnings`                 | Non-blocking issues that may reduce quality or eligibility               |
| `schemaOrgIssues`          | Problems specific to Schema.org spec compliance                          |
| `googleRichResultWarnings` | Fields missing or incorrect for Google Rich Result eligibility           |
| `seoRecommendations`       | Suggestions for improving schema quality beyond the minimum requirements |
| `correctedSchema`          | A suggested fixed version of your schema, generated automatically        |

## Schema.org errors vs. Google Rich Result warnings

These two categories are intentionally separate and mean different things for your SEO strategy.

**Schema.org issues** are structural errors. If your `Product` schema is missing `@context`, has a `price` value that is a string where a number is expected, or references an undefined property type, these will appear as `schemaOrgIssues`. A schema with these errors may not be read correctly by any search engine.

**Google Rich Result warnings** appear in `googleRichResultWarnings` and represent fields that are optional in Schema.org but required or expected by Google to qualify for enhanced search appearances. For example, a `Product` schema without `aggregateRating` or `offers` is valid Schema.org, but will not show star ratings or prices in Google Search. Fix these if Rich Results matter for the page.

<Tip>
  Prioritize fixing Schema.org issues first—they affect all search engines. Then address Google Rich Result warnings for pages where enhanced appearance in Google Search is a priority.
</Tip>

## The corrected schema

When the validator detects fixable problems, it generates a `correctedSchema`: a complete, ready-to-use JSON-LD object with the issues resolved as best as the system can determine. You can copy this corrected version directly from the validation result panel.

The corrected schema handles common fixes automatically: adding missing `@context`, coercing values to their correct types, adding placeholder values for required missing fields (clearly marked so you know to fill them in), and restructuring nested objects that are incorrectly formatted.

<Note>
  The corrected schema is a suggestion, not a guarantee. Review it before using it, especially for fields where a placeholder was added. Placeholder values like `"MISSING_VALUE"` need to be replaced with your actual content before the schema is meaningful.
</Note>

## Common validation errors and how to fix them

<AccordionGroup>
  <Accordion title="Missing required field">
    **What it looks like:** `Issue: Required property 'name' is missing.`

    **What it means:** The schema type requires this field to be present. Without it, the schema fails Schema.org validation.

    **How to fix it:** Open the schema in the editor, locate the missing field (it will be marked with a red asterisk), and fill it in. If you used AI extraction and the page didn't have this information visible, add it manually.
  </Accordion>

  <Accordion title="Wrong property type">
    **What it looks like:** `Issue: Property 'price' expected type Number, got String.`

    **What it means:** You've entered a value in a format that doesn't match what Schema.org expects. Prices should be numbers (`29.99`), not strings (`"$29.99"`). Dates should follow ISO 8601 (`2026-09-01`), not free-form text (`September 1, 2026`).

    **How to fix it:** Edit the field and correct the format. The field's help text in the Schema Builder shows the expected format.
  </Accordion>

  <Accordion title="Invalid URL format">
    **What it looks like:** `Issue: Property 'url' must be a valid URL.`

    **What it means:** A URL field contains something that isn't a valid URL—missing protocol (`https://`), a relative path, or a plain text string.

    **How to fix it:** Enter the full absolute URL including the protocol. For example, use `https://example.com/page` not `/page` or `example.com/page`.
  </Accordion>

  <Accordion title="Google Rich Result: missing recommended fields">
    **What it looks like:** `Google Rich Result Warning: 'aggregateRating' is recommended for Product rich results.`

    **What it means:** Your schema is valid Schema.org but is missing fields that Google looks for when deciding whether to show a Rich Result for this page type. This is a warning, not an error—your schema will still be indexed, but the page may not get enhanced search appearance.

    **How to fix it:** Add the recommended fields to your schema. For `Product`, this typically means adding `offers` with a price and `aggregateRating` if you have review data. For `Article`, add `author` and `datePublished`.
  </Accordion>

  <Accordion title="Missing @context or @type">
    **What it looks like:** `Issue: JSON-LD must include @context set to 'https://schema.org'.`

    **What it means:** The schema is missing the root-level `@context` or `@type` declarations that tell parsers what vocabulary and type you're using. This is a fundamental structural error.

    **How to fix it:** Use the corrected schema from the validation result, which adds these automatically. If you're editing JSON-LD by hand, every schema must begin with `"@context": "https://schema.org"` and `"@type": "YourType"`.
  </Accordion>
</AccordionGroup>


# CMS Embed API: Server-Side JSON-LD Schema Delivery
Source: https://docs.schemagen.io/integrations/cms-embed

Deliver JSON-LD schemas server-side using SchemaGen's Embed API—ideal for WordPress, Shopify Liquid, PHP templates, and performance-critical sites.

The SchemaGen Embed API is an alternative schema delivery method for environments where the JavaScript SDK is not suitable. Instead of loading a client-side script, your CMS template or server fetches a URL from SchemaGen at request time and injects the returned HTML — a `<script type="application/ld+json">` tag containing your deployed schema — directly into the page `<head>` before it reaches the browser.

This approach avoids any JavaScript dependency for schema delivery, which benefits server-rendered CMS platforms, AMP pages, and sites where minimizing JavaScript execution is a priority for Core Web Vitals.

## JS SDK vs Embed API

Use this table to decide which delivery method fits your setup:

|                     | JS SDK                                  | Embed API                                   |
| ------------------- | --------------------------------------- | ------------------------------------------- |
| **Setup**           | Add one `<script>` tag to `<head>`      | Fetch a URL from your template or server    |
| **Rendering**       | Client-side, after page load            | Server-side, in the initial HTML response   |
| **Best for**        | SPAs, headless frontends, any HTML site | WordPress, Shopify, PHP, AMP                |
| **Core Web Vitals** | No impact on LCP/CLS, async loaded      | Schema in initial HTML, zero JS overhead    |
| **Caching**         | CDN-cached SDK                          | Response cached with standard cache headers |

<Note>
  The Embed API response is cached by SchemaGen's edge infrastructure using standard HTTP cache headers. Fetching it server-side on every page request is fast and will not add meaningful latency to your page load times.
</Note>

## The embed endpoint

```
GET https://schemagen.io/api/embed?clientId={clientId}&url={pageUrl}
```

**Parameters:**

| Parameter  | Required | Description                                                             |
| ---------- | -------- | ----------------------------------------------------------------------- |
| `clientId` | Yes      | Your SchemaGen client ID, found in **Dashboard → Settings → Client ID** |
| `url`      | Yes      | The absolute URL of the page being rendered, URL-encoded                |

**Response:** Plain HTML containing one or more `<script type="application/ld+json">` tags for every schema you have published for that URL. If no schemas are deployed for that URL, the response is empty — your page renders normally with no errors.

## Code examples

<Tabs>
  <Tab title="WordPress PHP">
    Add this snippet to your theme's `functions.php` or directly in the `<head>` section of `header.php`. It uses WordPress's built-in HTTP API to fetch the schema and echoes the result into the page head.

    ```php header.php theme={null}
    <?php
    $client_id = 'YOUR_CLIENT_ID';
    $page_url = 'https://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
    $embed_url = 'https://schemagen.io/api/embed?clientId=' . urlencode($client_id) . '&url=' . urlencode($page_url);
    $response = wp_remote_get($embed_url);
    if (!is_wp_error($response)) {
        echo wp_remote_retrieve_body($response);
    }
    ?>
    ```

    Place this call inside `<head>...</head>` so the structured data is included in the initial HTML document.
  </Tab>

  <Tab title="Shopify Liquid">
    Add this snippet to your `theme.liquid` layout file inside the `<head>` block. Shopify Liquid's `fetch` filter makes the server-side request during render.

    ```liquid theme.liquid theme={null}
    {% assign schema_url = 'https://schemagen.io/api/embed?clientId=YOUR_CLIENT_ID&url=' | append: canonical_url %}
    {% assign schema_html = schema_url | fetch %}
    {{ schema_html }}
    ```

    Replace `YOUR_CLIENT_ID` with your actual client ID. The `canonical_url` variable is set automatically by Shopify for each page.
  </Tab>

  <Tab title="Generic PHP">
    For any PHP-based CMS or custom server, use `file_get_contents` or a cURL request:

    ```php theme={null}
    <?php
    $client_id = 'YOUR_CLIENT_ID';
    $page_url = (isset($_SERVER['HTTPS']) ? 'https' : 'http') . '://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
    $embed_url = 'https://schemagen.io/api/embed?clientId=' . rawurlencode($client_id) . '&url=' . rawurlencode($page_url);
    $schema_html = @file_get_contents($embed_url);
    if ($schema_html !== false) {
        echo $schema_html;
    }
    ?>
    ```
  </Tab>

  <Tab title="JavaScript fetch">
    If your environment renders server-side JavaScript (Next.js, Nuxt, SvelteKit) or you need a client-side fallback, use the fetch approach:

    ```javascript theme={null}
    fetch(
      'https://schemagen.io/api/embed?clientId=YOUR_CLIENT_ID&url=' +
      encodeURIComponent(window.location.href)
    )
      .then(r => r.text())
      .then(html => {
        const div = document.createElement('div');
        div.innerHTML = html;
        document.head.appendChild(div.firstChild);
      });
    ```

    <Warning>
      Fetching via client-side JavaScript defeats the server-rendering advantage of the Embed API. Use this approach only as a fallback. For true server-side delivery, use the PHP or Liquid examples above.
    </Warning>
  </Tab>
</Tabs>

## How to find your client ID

Your client ID is a UUID assigned to your SchemaGen account. Find it in **Dashboard → Settings → Client ID**. It is the same identifier used in the JS SDK's `data-client-id` attribute:

```html theme={null}
<script async
  src="https://schemagen.io/sdk.js"
  data-client-id="YOUR_CLIENT_ID">
</script>
```

Both the SDK and the Embed API use the same client ID — if you are migrating from one delivery method to the other, no changes are needed to your schema configurations in the dashboard.

## How schema matching works

When the Embed API receives a request, it looks up all schemas you have published for the exact URL provided in the `url` parameter. Make sure the URL you pass matches the canonical URL of the page as you have configured it in the SchemaGen dashboard. Including or excluding trailing slashes, query strings, or `www` inconsistently will result in no schemas being returned.

<Tip>
  Always pass the canonical URL of the page — the same URL you used when deploying the schema in the dashboard. For WordPress, this is `get_permalink()`. For Shopify, use the `canonical_url` variable as shown in the Liquid example.
</Tip>


# Track Schema Performance with Google Search Console
Source: https://docs.schemagen.io/integrations/google-search-console

Connect your GSC property to SchemaGen to see impressions, clicks, and CTR for every page where structured data is deployed—all in one dashboard.

The Google Search Console integration surfaces real performance data inside your SchemaGen dashboard. Once connected, you can see impressions, clicks, and click-through rate for every page where you have an active schema—so you can measure the direct SEO impact of your structured data deployments without leaving SchemaGen.

<Warning>
  The Google Search Console integration requires a **Pro** ($29/mo) or **Agency** ($99/mo) plan. It is not available on the Free tier. You can upgrade at any time from **Dashboard → Account → Plans**.
</Warning>

## What the integration does

After you connect, SchemaGen reads data from your GSC property with read-only access. It then correlates that performance data with the schemas you have deployed, giving you a per-page view of:

* **Impressions** — how many times your pages appeared in Google Search results
* **Clicks** — how many users clicked through to your site
* **CTR** — the ratio of clicks to impressions, expressed as a percentage

This data updates on Google's standard processing delay, so expect a lag of one to two days before new data appears in the SchemaGen dashboard.

<Note>
  Google Search Console data typically lags 1–2 days behind real-time. If you just deployed a schema, check back the following day for updated performance figures.
</Note>

## Requirements

Before connecting, confirm the following:

* You are on a **Pro** or **Agency** plan
* You have a Google Search Console property already verified for your domain
* You are signed in to Google with an account that has at least **Owner** or **Full User** access to that GSC property

## Connect your Google Search Console property

<Steps>
  <Step title="Open the Integrations page">
    Log in to your SchemaGen dashboard and navigate to **Settings → Integrations**. You will see a list of available integrations, including Google Search Console.
  </Step>

  <Step title="Start the connection">
    Click **Connect Google Search Console**. SchemaGen initiates an OAuth 2.0 flow by redirecting you to Google's authorization screen.
  </Step>

  <Step title="Authorize SchemaGen">
    Review the permissions Google displays. SchemaGen requests **read-only** access to your Search Console data — it cannot modify your GSC settings or property. Click **Allow** to continue.

    <Tip>
      If your Google account has access to multiple GSC properties, you will be prompted to select which property to connect. Choose the one that matches the domain where you have SchemaGen installed.
    </Tip>
  </Step>

  <Step title="Select your Search Console property">
    After authorizing, SchemaGen shows a list of GSC properties available under your Google account. Select the property that corresponds to your site and click **Confirm**.
  </Step>

  <Step title="Verify the connection">
    You will be returned to the Integrations page with a **Connected** status shown next to Google Search Console. Your performance data will begin populating within 24–48 hours, depending on Google's data pipeline.
  </Step>
</Steps>

## What you see after connecting

Once the integration is active, a **Performance** panel appears on individual schema pages and in the main dashboard overview. The data is scoped to URLs where you have at least one published schema.

<CardGroup>
  <Card title="Impressions" icon="eye">
    Total search appearances for each page with an active schema, pulled directly from GSC.
  </Card>

  <Card title="Clicks" icon="arrow-pointer">
    The number of times users clicked your result in Google Search.
  </Card>

  <Card title="Click-through rate" icon="chart-line">
    Your CTR shown as a percentage, with trend indicators comparing the period before and after schema deployment.
  </Card>
</CardGroup>

## Interpreting performance data

A rise in CTR after deploying a schema is a strong signal that your structured data is influencing how Google presents your result. Rich results — such as star ratings, FAQ dropdowns, or product prices — increase visual prominence in the SERP, which often drives higher click-through rates even without a change in ranking position.

When analyzing your data, compare the 28-day window before you published a schema against the 28-day window after. A consistent CTR improvement of 1–3 percentage points on informational content, or higher on product and review pages, indicates your schema deployment is performing well.

<Info>
  Impressions can increase independently of CTR if Google begins showing your pages for new queries after indexing your structured data. Both signals together give you the clearest picture of impact.
</Info>

Agency plan subscribers also get access to the **GSC Performance Loop**, which automatically surfaces pages with published schemas that show declining CTR. This helps you prioritize which schemas to update or expand before performance erodes further.

## Disconnect the integration

To remove the connection, go to **Settings → Integrations → Google Search Console** and click **Disconnect**. This revokes SchemaGen's access to your GSC data and removes the performance panels from your dashboard. Your schemas remain active and unaffected — only the performance data overlay is removed.

You can reconnect at any time by repeating the steps above.


# What is SchemaGen? Schema Delivery Network for SEO
Source: https://docs.schemagen.io/introduction

SchemaGen is an SDN that lets SEO teams deploy and manage JSON-LD structured data across any website without touching code or the CMS.

SchemaGen is a Schema Delivery Network (SDN) built for SEO teams who need full control over structured data — without waiting for developers or CMS access. Install a single script tag once, and every schema you create, update, or pause lives entirely in the SchemaGen dashboard. No code changes. No deployment pipeline. No tickets.

## The problem SchemaGen solves

Structured data is one of the highest-leverage SEO tactics available, but most teams can't move fast enough to capture it. Adding or updating JSON-LD typically means filing a developer request, waiting for a sprint, and hoping the change ships before the next algorithm update. SchemaGen removes that bottleneck entirely.

With SchemaGen, you own the schema layer of your website the same way a CDN owns asset delivery. The SDK lives on your site; everything else — building, editing, publishing, pausing — happens from your dashboard in real time.

## How it works

SchemaGen follows a three-step workflow from creation to live delivery.

<Steps>
  <Step title="Build">
    Create JSON-LD in the Schema Builder using the full Schema.org vocabulary (800+ types, 1,200+ properties), or paste any URL and let AI extraction generate production-ready markup automatically.
  </Step>

  <Step title="Deploy">
    Click **Publish** to push your schema to the SDN instantly. The SchemaGen SDK on your site fetches and injects the correct schemas for each page — no re-deployment required.
  </Step>

  <Step title="Monitor">
    Connect Google Search Console to track impressions, clicks, and CTR tied directly to your published schemas. See what's working and iterate without leaving the dashboard.
  </Step>
</Steps>

## Key features

<CardGroup>
  <Card title="Schema Delivery Network" icon="network-wired" href="/sdn/overview">
    One script tag on your site. All schema updates — create, edit, pause, republish — happen from the dashboard with zero code changes.
  </Card>

  <Card title="AI extraction" icon="wand-magic-sparkles" href="/features/ai-extraction">
    Paste a URL and get production-ready JSON-LD in seconds. AI reads the page and generates accurate, valid markup automatically.
  </Card>

  <Card title="Full Schema.org vocabulary" icon="sitemap" href="/features/schema-builder">
    Access all 800+ Schema.org types and 1,200+ properties. Not limited to Google-supported types — build any valid structured data you need.
  </Card>

  <Card title="Draft / Publish / Pause" icon="toggle-on" href="/sdn/publishing">
    Manage the full schema lifecycle from the dashboard. Draft schemas for review, publish when ready, and pause instantly without touching your site.
  </Card>

  <Card title="Google Search Console integration" icon="chart-line" href="/integrations/google-search-console">
    Connect GSC to measure the real-world SEO impact of your schemas with impressions, clicks, and CTR data tied to individual schema deployments.
  </Card>

  <Card title="Bulk generation" icon="layer-group" href="/features/bulk-generation">
    Generate schemas for up to 100 URLs in a single run. Ideal for large sites, content migrations, and agency clients with high page volumes.
  </Card>
</CardGroup>

## Plans at a glance

SchemaGen offers three plans designed to grow with your team.

| Feature             | Free                  | Pro             | Agency          |
| ------------------- | --------------------- | --------------- | --------------- |
| Price               | \$0                   | \$29/mo         | \$99/mo         |
| Saved schemas       | 5                     | Unlimited       | Unlimited       |
| Schema types        | Google-supported only | Full Schema.org | Full Schema.org |
| AI extraction       | —                     | Yes             | Yes             |
| Bulk generation     | —                     | 10 URLs/run     | 100 URLs/run    |
| AI site audit + PDF | —                     | —               | Yes             |
| Client portfolios   | —                     | —               | Yes             |
| Team seats          | 1                     | 1               | 5               |
| Priority support    | —                     | —               | Yes             |

<Note>
  The Free plan includes 5 saved schemas and covers Google-supported schema types. Upgrade to Pro or Agency to unlock AI features, the full Schema.org vocabulary, and higher limits.
</Note>

## Get started

<CardGroup>
  <Card title="Quick start guide" icon="rocket" href="/quickstart">
    Create your account and deploy your first schema in under five minutes.
  </Card>

  <Card title="SDK installation" icon="code" href="/sdk-installation">
    Add the SchemaGen SDK to your site — HTML, WordPress, Shopify, or Next.js.
  </Card>
</CardGroup>


# Quick start: Deploy your first schema in 5 minutes
Source: https://docs.schemagen.io/quickstart

Create a SchemaGen account, build your first JSON-LD schema, publish it to the SDN, and install the SDK to go live on your website.

This guide walks you through everything you need to get from a blank slate to a live schema on your website. By the end, your site will automatically receive and inject schemas you publish from the SchemaGen dashboard — no further code changes required.

<Note>
  The Free plan includes 5 saved schemas. If you need unlimited schemas, AI extraction, or bulk generation, upgrade to Pro ($29/mo) or Agency ($99/mo) from your account settings.
</Note>

<Steps>
  <Step title="Create your account">
    Go to [schemagen.io](https://schemagen.io) and sign up for a free account. No credit card is required for the Free plan.

    After signing up, you land on the SchemaGen dashboard. This is where you'll manage all your schemas, domains, and settings.
  </Step>

  <Step title="Add your website domain">
    In the dashboard, navigate to **Settings → Domains** and add the domain you want to deploy schemas to (for example, `example.com`).

    SchemaGen uses your registered domain to scope schema delivery so that schemas only inject on matching pages. You can add multiple domains under the Pro and Agency plans.
  </Step>

  <Step title="Create a new schema">
    Click **New Schema** from the dashboard home or the **Schemas** section in the sidebar.

    You'll be prompted to choose how you want to build your schema:

    * **Schema Builder** — use the guided form interface to manually select a Schema.org type and fill in properties. Available on all plans.
    * **AI extraction** — paste a URL and let SchemaGen generate production-ready JSON-LD automatically. Available on Pro and Agency plans.

    <Tip>
      If you're on the Free plan, start with a high-value page type like `Article`, `Product`, or `LocalBusiness` — these are Google-supported types that qualify for rich results.
    </Tip>

    Enter a name for your schema (this is for your reference only) and select the **Target URL** — the specific page this schema applies to.
  </Step>

  <Step title="Build your JSON-LD">
    Fill in the schema properties using the Schema Builder form. Required fields are marked; add as many optional fields as you can to improve data completeness.

    If you used AI extraction, review the generated JSON-LD and make any corrections. You can switch to the **Code** tab at any time to edit the raw JSON-LD directly.

    When you're done, click **Save as draft**. This saves your schema without publishing it to the SDN, so you can validate and review before it goes live.
  </Step>

  <Step title="Validate your schema">
    From the schema editor, click **Validate**. SchemaGen checks your JSON-LD against Schema.org specifications and Google Rich Result guidelines and reports any errors or warnings.

    Fix any errors before publishing. Warnings are non-blocking but worth reviewing — they often indicate missing fields that can improve rich result eligibility.

    <Warning>
      Publishing a schema with validation errors will not prevent delivery, but invalid markup may not be processed correctly by search engines.
    </Warning>
  </Step>

  <Step title="Publish to the SDN">
    Once your schema passes validation, click **Publish**. Your schema is immediately pushed to the SchemaGen Schema Delivery Network.

    From this point, any page on your site that matches the target URL will receive this schema — as soon as the SDK is installed (see the next step).

    You can return to this schema at any time to edit, pause, or unpublish it. Changes propagate instantly to the SDN with no code changes required.
  </Step>

  <Step title="Install the SDK on your site">
    For your schemas to be injected into your pages, you need to install the SchemaGen SDK on your website. This is a one-time setup.

    See the [SDK installation guide](/sdk-installation) for step-by-step instructions for HTML/static sites, WordPress, Shopify, and Next.js.

    Your **Client ID** is available in **Settings → Client** in the dashboard. You'll need it when adding the SDK snippet to your site.
  </Step>

  <Step title="Verify your schema is live">
    After installing the SDK, open the target page in your browser and inspect the page source (right-click → **View page source**) or open browser DevTools.

    Look for a `<script type="application/ld+json">` tag in the `<head>` or `<body>` — this is your published schema, injected by the SDK.

    You can also use Google's [Rich Results Test](https://search.google.com/test/rich-results) to confirm your schema is valid and detectable by Google.

    <Tip>
      It may take a few seconds after the page loads for the SDK to fetch and inject schemas. If you don't see the script tag immediately, wait for the page to fully load and check again in DevTools under the **Elements** tab.
    </Tip>
  </Step>
</Steps>

## What's next

Now that your first schema is live, explore these areas to get more out of SchemaGen.

<CardGroup>
  <Card title="AI extraction" icon="wand-magic-sparkles" href="/features/ai-extraction">
    Speed up schema creation by pasting a URL and generating JSON-LD automatically.
  </Card>

  <Card title="Bulk generation" icon="layer-group" href="/features/bulk-generation">
    Generate schemas for up to 100 URLs at once — ideal for large sites or content migrations.
  </Card>

  <Card title="Google Search Console" icon="chart-line" href="/integrations/google-search-console">
    Connect GSC to measure impressions and CTR changes driven by your schemas.
  </Card>

  <Card title="Site audit" icon="magnifying-glass-chart" href="/features/audit-tool">
    Scan your entire domain for structured data gaps and export a PDF report.
  </Card>
</CardGroup>


# Install the SchemaGen SDK on Your Website in Minutes
Source: https://docs.schemagen.io/sdk-installation

Add the SchemaGen SDK snippet once to HTML, WordPress, Shopify, or Next.js sites to enable real-time JSON-LD delivery from your dashboard.

The SchemaGen SDK is a lightweight JavaScript snippet that connects your website to the Schema Delivery Network. When a visitor loads a page, the SDK reads the current URL, fetches any published schemas that match that page from SchemaGen's edge network, and injects them into the DOM as `<script type="application/ld+json">` tags — automatically, with no further action required from you.

You install the SDK once. Every schema you publish, update, or pause from the dashboard takes effect immediately across all matching pages on your site.

<Note>
  The SDK is lightweight and edge-optimized. It loads asynchronously so it never blocks page rendering, and schema delivery is served from edge locations worldwide to minimize latency.
</Note>

## Find your Client ID

Before you install the SDK, locate your **Client ID**. This unique identifier tells the SDK which schemas to fetch for your site.

To find it: in the SchemaGen dashboard, go to **Settings → Client**. Your Client ID is displayed there. Copy it — you'll paste it into the SDK snippet below.

## Install the SDK

Choose the installation method that matches your site setup.

<Tabs>
  <Tab title="HTML / Static">
    Add the following snippet inside the `<head>` tag of every page on your site. If you use a shared layout or template file, add it there so it appears on all pages automatically.

    Replace `YOUR_CLIENT_ID` with the Client ID from your dashboard.

    ```html HTML theme={null}
    <script async
      src="https://schemagen.io/sdk.js"
      data-client-id="YOUR_CLIENT_ID">
    </script>
    ```

    Place the tag as early in the `<head>` as possible to give the SDK time to fetch schemas before the page finishes rendering.
  </Tab>

  <Tab title="WordPress">
    The best way to add the SDK to WordPress is via your theme's `functions.php` file or a site-wide plugin like **Code Snippets**.

    Add the following to your `functions.php` file (or a custom plugin):

    ```php functions.php theme={null}
    function schemagen_sdk() {
      echo '<script async src="https://schemagen.io/sdk.js" data-client-id="YOUR_CLIENT_ID"></script>';
    }
    add_action( 'wp_head', 'schemagen_sdk' );
    ```

    Replace `YOUR_CLIENT_ID` with the Client ID from your dashboard.

    <Tip>
      If you're using a page builder like Elementor or a theme with a **Custom Code** or **Header Scripts** field, you can paste the raw `<script>` tag there instead of editing `functions.php`.
    </Tip>

    After saving, load any page on your site and verify the script tag appears in the page source.
  </Tab>

  <Tab title="Shopify">
    In your Shopify admin, go to **Online Store → Themes → Edit code**. Open `layout/theme.liquid` and paste the snippet just before the closing `</head>` tag.

    Replace `YOUR_CLIENT_ID` with the Client ID from your dashboard.

    ```html theme.liquid theme={null}
    <script async
      src="https://schemagen.io/sdk.js"
      data-client-id="YOUR_CLIENT_ID">
    </script>

    </head>
    ```

    Click **Save**. The SDK will now load on every page of your storefront.

    <Note>
      Shopify's online storefront renders different URLs for product pages, collections, blogs, and the homepage. SchemaGen matches schemas by the exact URL the SDK detects, so make sure your target URLs in the dashboard match your Shopify URL structure (for example, `https://your-store.myshopify.com/products/example-product`).
    </Note>
  </Tab>

  <Tab title="Next.js / React">
    In Next.js, use the built-in `next/script` component to load the SDK. Add it to your root layout so it appears on every page.

    Replace `YOUR_CLIENT_ID` with the Client ID from your dashboard.

    ```jsx app/layout.jsx theme={null}
    import Script from 'next/script'

    export default function RootLayout({ children }) {
      return (
        <html>
          <body>
            {children}
            <Script
              src="https://schemagen.io/sdk.js"
              data-client-id="YOUR_CLIENT_ID"
              strategy="afterInteractive"
            />
          </body>
        </html>
      )
    }
    ```

    The `afterInteractive` strategy loads the SDK after the page becomes interactive, keeping it out of the critical rendering path while ensuring schemas are injected before users interact with the content.

    <Tip>
      If you're using the Pages Router instead of the App Router, add the `<Script>` component to `pages/_app.jsx` in the same way.
    </Tip>
  </Tab>
</Tabs>

## How the SDK works

When the SDK loads on a page, it:

1. Reads the current page URL from the browser.
2. Sends a request to the SchemaGen inject API: `GET /api/inject?clientId={clientId}&url={pageUrl}`.
3. Receives a list of published schemas matching that URL.
4. Injects each schema as a `<script type="application/ld+json">` tag into the page DOM.

Schemas are only delivered if they match the target URL you configured in the dashboard and have a **Published** status. Drafts and paused schemas are never delivered to the browser.

## Verify the SDK is working

After installing the SDK, confirm it's injecting schemas correctly.

<Steps>
  <Step title="Open DevTools">
    Navigate to a page where you have a published schema. Open your browser's developer tools (press `F12` or right-click → **Inspect**).
  </Step>

  <Step title="Check the Elements panel">
    In the **Elements** tab, search for `application/ld+json` (use `Ctrl+F` or `Cmd+F` to search within the DOM). You should see one or more `<script type="application/ld+json">` tags containing your schema JSON.
  </Step>

  <Step title="Check the Network panel">
    In the **Network** tab, filter by `Fetch/XHR` and reload the page. Look for a request to `schemagen.io/api/inject` — this confirms the SDK is running and communicating with the SchemaGen edge network.
  </Step>
</Steps>

<Warning>
  If you don't see schemas being injected, double-check that the `data-client-id` attribute contains your correct Client ID, that the target URL in your dashboard exactly matches the page URL (including protocol and path), and that the schema has a **Published** status — not Draft or Paused.
</Warning>

## Next steps

<CardGroup>
  <Card title="Quick start guide" icon="rocket" href="/quickstart">
    Walk through creating and publishing your first schema end to end.
  </Card>

  <Card title="SDN overview" icon="network-wired" href="/sdn/overview">
    Learn how the Schema Delivery Network routes and caches schema delivery.
  </Card>

  <Card title="Publishing and lifecycle" icon="toggle-on" href="/sdn/publishing">
    Understand how Draft, Published, and Paused states affect schema delivery.
  </Card>

  <Card title="Domain locking" icon="lock" href="/sdn/domain-locking">
    Restrict your Client ID to specific domains to prevent unauthorized use.
  </Card>
</CardGroup>


# Domain Locking: Restrict Which Sites Receive Your Schemas
Source: https://docs.schemagen.io/sdn/domain-locking

Protect your SDN client by allowing schema delivery only to approved domains. Requests from other domains are blocked automatically at the edge.

Domain locking lets you control exactly which domains are permitted to receive schemas from your SDN client. When domain locking is enabled, the SDN checks the requesting domain against your allowlist before returning any schema data. Requests from domains not on the list are rejected entirely.

<Warning>
  Domain locking is available on the **Agency plan** (\$99/mo) only. If you're on the Free or Pro plan, all domains can request schemas from your client by default. [Upgrade to Agency](https://schemagen.io/pricing) to enable domain locking.
</Warning>

## Why domain locking matters

Your SDN client ID is embedded in your site's script tag. In principle, anyone who finds that client ID could point their own site at your SDN client and load your published schemas. Domain locking prevents this by enforcing an allowlist at the edge—before any schema data is returned.

Use domain locking to:

* **Prevent schema leakage** to unauthorized sites or competitors
* **Protect client schemas** when managing schemas for multiple client websites under a single agency account
* **Enforce delivery boundaries** when your client ID is used across staging, production, and third-party domains

## How the SDN enforces domain locking

When a page loads your SDK script tag, the SDK calls the inject API:

```
GET /api/inject?clientId=YOUR_CLIENT_ID&url=https://yoursite.com/page
```

The SDN reads the `Origin` header of this request. If domain locking is enabled for the client and the requesting origin is not in your allowlist, the SDN returns a `403 Forbidden` response. No schema data is included in the response. The SDK silently handles the blocked response—your site continues to function normally, just without schema injection on that domain.

## Configuring domain locking

<Steps>
  <Step title="Open Client Settings">
    In your SchemaGen dashboard, navigate to **Clients** and select the client you want to protect. Click **Settings** to open the client configuration panel.
  </Step>

  <Step title="Go to the Domains tab">
    Inside Client Settings, select the **Domains** tab. This is where you manage the allowlist for SDN delivery.
  </Step>

  <Step title="Add your allowed domains">
    Click **Add Domain** and enter each domain that should be permitted to receive schemas from this client. Add your production domain first, then any staging or preview environments you want to allow.
  </Step>

  <Step title="Save your settings">
    Click **Save**. Domain locking activates immediately—requests from domains not on your list are blocked from this point forward.
  </Step>
</Steps>

## Supported domain formats

You can add domains in the following formats:

| Format               | Example               | What it matches                                               |
| -------------------- | --------------------- | ------------------------------------------------------------- |
| Exact domain         | `example.com`         | Only `example.com`                                            |
| Wildcard subdomain   | `*.example.com`       | Any subdomain: `www.example.com`, `staging.example.com`, etc. |
| Subdomain + wildcard | `staging.example.com` | Only `staging.example.com`                                    |

Use wildcard entries (`*.example.com`) when you want to cover all subdomains of a root domain—for example, if your agency uses preview URLs like `client-preview.youragency.com` across multiple projects.

<Note>
  After saving your domain settings, test delivery from each allowed domain to confirm schemas are being injected correctly. Open your browser's developer tools, load a page where a published schema is targeted, and check the **Network** tab for a successful response from `/api/inject`. A `200` response means delivery is working; a `403` means the domain is not on the allowlist.
</Note>

## What an unauthorized request looks like

If a domain that is not on your allowlist attempts to load schemas from your client, the SDN blocks the request:

```
GET /api/inject?clientId=YOUR_CLIENT_ID&url=https://unauthorized-site.com/page
→ 403 Forbidden
```

The SDK handles this gracefully—no errors are thrown on the page, and the site loads normally without schema injection. Your published schemas remain private to your approved domains.

## Removing or updating domain entries

To update your allowlist at any time:

1. Go to **Clients → Settings → Domains**
2. Remove or edit any existing entries
3. Add new domains as needed
4. Click **Save**

Changes to your domain allowlist take effect immediately. If you remove a domain that was previously allowed, the SDN begins blocking requests from that domain on the next SDK call.

<Warning>
  If you remove your own production domain from the allowlist by mistake, schema delivery to your live site will stop immediately. Keep your production domain on the list at all times, and double-check your entries before saving.
</Warning>


# What Is the Schema Delivery Network and How It Works
Source: https://docs.schemagen.io/sdn/overview

The SchemaGen SDN decouples structured data from your codebase—deploy and update JSON-LD from the dashboard instantly, with no code changes required.

The Schema Delivery Network (SDN) is SchemaGen's core delivery engine. It separates your structured data from your website's source code entirely—install a single script tag once, and every schema you create, edit, or remove takes effect immediately from the dashboard, with no code changes, CMS access, or developer involvement required.

## How the SDN works

When a visitor lands on a page of your site, the SchemaGen SDK (loaded via your script tag) sends a request to the SDN edge with your client ID and the current page URL. The SDN matches that URL against your published schemas and returns the appropriate JSON-LD, which the SDK injects directly into the page's DOM before search engines crawl it.

```
Visitor loads page
  → SDK calls GET /api/inject?clientId=YOUR_CLIENT_ID&url=https://yoursite.com/page
  → SDN returns matching published schemas as JSON-LD
  → SDK injects <script type="application/ld+json"> tags into the DOM
```

The SDK tag itself is lightweight and loads asynchronously—it never blocks your page from rendering.

<Note>
  The SDK script uses the `async` attribute, so it loads in the background and has no impact on your page's rendering or Core Web Vitals scores.
</Note>

## Installing the SDK

Add this single tag to the `<head>` of every page on your site—or use your CMS's global head injection setting. Replace `YOUR_CLIENT_ID` with the client ID shown in your SchemaGen dashboard.

```html theme={null}
<script async
  src="https://schemagen.io/sdk.js"
  data-client-id="YOUR_CLIENT_ID">
</script>
```

This is the only change you ever need to make to your site. All schema management happens from the dashboard after this point.

## Edge-optimized delivery

The SDN runs on edge infrastructure, meaning schema requests are resolved at network locations geographically close to your visitors. In practice, this means:

* **Sub-100ms response times** for schema fetches worldwide
* **No caching of schema data** (`Cache-Control: no-store`)—so published changes and pauses take effect instantly on the next page load
* **Per-request tracing** via `X-Schemagen-ID` and `X-Schemagen-Duration` response headers, useful if you're debugging delivery with your browser's developer tools

## Schema states

Every schema in your dashboard has one of three statuses. The status controls whether the SDN delivers it to your site.

<CardGroup>
  <Card title="Draft" icon="pen-to-square">
    The schema is saved in your dashboard but not yet live. The SDN will never deliver a draft schema, regardless of URL targeting. Use this state to build and review before going live.
  </Card>

  <Card title="Published" icon="circle-check">
    The schema is live on the SDN. Whenever the SDK detects a page URL that matches this schema's target, the JSON-LD is injected into the DOM. Changes to a published schema go live instantly.
  </Card>

  <Card title="Paused" icon="circle-pause">
    The schema is temporarily removed from delivery without being deleted. The SDN stops serving it immediately, but all your data and settings are preserved. Unpause to resume delivery at any time.
  </Card>
</CardGroup>

## The old way vs. the SDN way

Managing structured data without SchemaGen means your schema lives inside your codebase—tied to templates, CMS themes, or developer-managed JSON-LD files. Every change requires a ticket, a deployment, and a wait.

| Situation                       | Without the SDN                              | With the SDN                                      |
| ------------------------------- | -------------------------------------------- | ------------------------------------------------- |
| Add a new schema to a page      | File a developer ticket, wait for deployment | Publish from the dashboard in seconds             |
| Fix a schema error              | Find the template file, update it, redeploy  | Edit the schema, save—live instantly              |
| Remove a schema temporarily     | Requires code change and deployment          | Click **Pause**—removed from delivery immediately |
| Update schema across many pages | Repetitive, error-prone manual work          | Update once, targeting applies everywhere         |

The SDN eliminates the dependency on development cycles for anything schema-related. SEO teams get direct control.

## What gets delivered

The SDN matches schemas to pages using the `pageUrl` field you set when creating or editing a schema. When the SDK requests schemas for a URL, the SDN returns only the published schemas whose target URL matches the current page. The SDK then injects each one as a separate `<script type="application/ld+json">` block.

The inject API response includes:

* `schemas` — the raw JSON-LD objects ready for injection
* `items` — full schema records including metadata
* `meta` — delivery metadata including API version, a unique request ID, and server timestamp

## Next steps

<CardGroup>
  <Card title="Publishing schemas" icon="cloud-arrow-up" href="/sdn/publishing">
    Step-by-step guide to taking a draft schema live on the SDN.
  </Card>

  <Card title="Domain locking" icon="shield-halved" href="/sdn/domain-locking">
    Restrict which domains can receive schemas from your SDN client (Agency plan).
  </Card>
</CardGroup>


# How to Publish, Edit, and Pause Schemas on the SDN
Source: https://docs.schemagen.io/sdn/publishing

Take a draft schema live on the Schema Delivery Network, make real-time edits to published schemas, pause delivery, or delete schemas from your dashboard.

Publishing a schema makes it live on the Schema Delivery Network. From that moment, every page on your site that matches the schema's target URL will have the JSON-LD injected by the SDK on each page load. This page walks you through publishing your first schema, editing a live schema, and managing schema delivery after it goes live.

## Prerequisites

Before you can publish a schema to the SDN, you need:

* The SchemaGen SDK installed on your site (see the [SDK installation guide](/sdk-installation))
* At least one schema saved as a draft in your dashboard

If the SDK isn't installed yet, any schemas you publish will be ready on the SDN but won't appear on your site until the script tag is in place.

## Publishing a draft schema

<Tip>
  Run schema validation before publishing. The validator checks your JSON-LD against Schema.org specifications and Google Rich Result guidelines, so you catch issues before they affect your site's structured data.
</Tip>

<Steps>
  <Step title="Open the schema">
    In your dashboard, navigate to **Schemas** and locate the schema you want to publish. Schemas in `draft` status are not yet live on the SDN.
  </Step>

  <Step title="Review the target URL">
    Confirm the **Page URL** field contains the exact URL of the page where this schema should appear. The SDN uses this URL to match incoming requests from the SDK. If the URL is wrong, the schema won't be delivered to the correct page.
  </Step>

  <Step title="Validate the schema">
    Click **Validate** to run the schema through SchemaGen's validator. Review any issues or warnings before continuing. Resolve critical issues before publishing—warnings are informational but issues can prevent rich results.
  </Step>

  <Step title="Click Publish">
    Click the **Publish** button. SchemaGen will prompt you to confirm that you want to make this schema live on the SDN.
  </Step>

  <Step title="Confirm">
    Confirm the action. The schema status changes from `draft` to `published` immediately. The SDN begins delivering the JSON-LD to matching page URLs on the next SDK request.
  </Step>
</Steps>

<Warning>
  Do not publish schemas that have validation errors. A schema with structural or property errors can cause Google to ignore the structured data entirely, or flag your site in Search Console. Fix all errors before publishing—warnings are safe to publish with, but errors are not.
</Warning>

## What happens when you publish

The moment you publish:

* The schema status updates to `published` in your dashboard
* The SDN edge makes the JSON-LD available for delivery
* Any page request matching your schema's target URL will receive the schema on the next SDK call
* The change is reflected without any code change, CMS update, or site deployment

There is no propagation delay. The SDN does not cache schema data between requests (`Cache-Control: no-store`), so published schemas are live immediately.

## How URL targeting works

The SDN delivers schemas by matching the URL the SDK sends—the exact URL of the page the visitor is on—against the **Page URL** you set on each schema. For the schema to be delivered:

* The page URL reported by the SDK must match the schema's target URL
* The schema must have `published` status
* If domain locking is enabled on your client, the requesting domain must be on the allowlist

Set the Page URL to the full, absolute URL of the target page, including the protocol: `https://yoursite.com/services/dentistry`.

## Editing a published schema

You can edit a published schema at any time from the dashboard. Changes go live on the SDN as soon as you save—there is no separate republish step.

To edit a published schema:

1. Open the schema from your **Schemas** list
2. Make your changes to any fields, properties, or the target URL
3. Click **Save**

The updated JSON-LD is available on the SDN immediately. The next page load that triggers an SDK request for that URL will receive the updated schema.

<Note>
  If you change the target URL of a published schema, delivery for the old URL stops immediately and begins for the new URL. Plan URL changes carefully, especially on high-traffic pages.
</Note>

## Pausing a schema

Pausing removes a schema from SDN delivery without deleting it. Use this when you need to temporarily stop delivering a schema—for example, during a site migration or if you discover an issue after publishing.

To pause a schema:

1. Open the schema from your **Schemas** list
2. Click **Pause**

The schema status changes from `published` to `paused`. The SDN stops delivering it immediately. Your schema data, target URL, and all settings are preserved—unpause at any time to resume delivery.

**Paused vs. draft:** Both states mean the schema is not delivered. The difference is intent—`draft` schemas are being built, `paused` schemas were previously live and are temporarily suspended.

## Deleting a schema

Deleting a schema permanently removes it from your dashboard and the SDN. This action cannot be undone.

To delete a schema:

1. Open the schema from your **Schemas** list
2. Click **Delete** (or the trash icon)
3. Confirm the deletion

If the schema was published at the time of deletion, the SDN stops delivering it immediately. Consider pausing instead of deleting if there's any chance you'll want the schema again.

<Warning>
  Deleting a schema is permanent. All schema data, history, and settings are removed and cannot be recovered. If you're unsure, pause the schema instead.
</Warning>