# FAQs for AEO

<figure><img src="https://16034713-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FM2xSzN6C9hL2ozNM8Yx0%2Fuploads%2FtvMm5K2VWm2DpFZzJGLr%2FAEO-ready%20FAQs%20built%20for%20AI.png?alt=media&#x26;token=1b6c0139-6771-450a-b221-b994e684c19c" alt=""><figcaption></figcaption></figure>

***

### Why FAQs Work for AEO

* AI engines look for a clear question paired with a clear answer — FAQs are built exactly that way, making them easy to read, cite, and surface in responses
* Shoppers get answers to common questions right at the point of decision, reducing friction and supporting conversion
* Structured FAQ content with proper schema tells AI engines not just what the answer is, but that it can be trusted and referenced confidently
* Every FAQ is a potential citation opportunity — when someone asks an AI what to buy or how something works, your product page becomes a candidate for the answer
* With Maker, you don't have to write them from scratch — we generate the questions and answers from your product URL, so your team just reviews and approves

***

### **How to Create FAQs with Maker**&#x20;

1. Open the Maker editor
2. Create an FAQ using a simple prompt like: "Generate FAQs for this PDP" and paste your product link. You can also include additional details such as number of questions, a "See all" toggle, search option, or accordion format
3. Once the FAQs are ready, run the prompt: **"Generate FAQ schema"**
4. Maker will check the project for existing FAQs first — if none are found, it will generate new ones for the JSON-LD schema

***

### **Where to find your FAQ schema**

Once generated, you can access it in three places:

1. **Download the JSON-LD Schema file: I**nside the Download button on any project, you’ll find a JSON-LD Schema download alongside the Project ZIP. This gives you a standalone `.json` file for that product’s FAQs.
2. **Schema URL from the Publish Modal:** When you publish a project, the Publish Modal includes an “Open JSON-LD Schema URL” link. This is a hosted URL that always serves the latest schema for that product. You can open it in a browser to view the raw schema, or use the URL directly in certain implementations.
3. **Copy with Simple Embed:** When you copy the Simple or iframe Embed code, the JSON-LD schema is automatically included alongside the embed script. This is the quickest option if you’re adding both the visual component and the schema to a page at the same time.

**Important: One schema per product**\
\&#xNAN;*Each product FAQ should have its own unique schema. You’ll need to add the correct schema to the matching product page on your store. There is no single schema file that works across all products. The steps below are repeated for each product you want to make AEO-ready.*

***

### CMS Implementation

*(These are the recommended steps. Please verify this in your own CMS.)*

***

### Shopify

Shopify’s Liquid templates render server-side, which is exactly what you need for the schema to be readable by AI crawlers. The recommended approach is to store each product’s schema in a metafield and reference it dynamically in your product template.<br>

**Step 1: Get the schema for your product**

From your Maker dashboard, open the project for the product you want to implement. Either download the JSON-LD Schema file or copy the schema content from the Schema URL.<br>

**Step 2: Add a metafield to the product in Shopify**

Metafields allow you to attach custom data to individual products in Shopify, which is exactly what we need here since every product has a different schema.

1\. In your Shopify admin, go to Settings > Custom Data > Products\
2\. Click Add definition\
3\. Name it something like `FAQ Schema` and set the namespace to `maker` and the key to `faq_schema`\
4\. Set the type to Multi-line text\
5\. Save the definition

Now go to the individual product:\
1\. Go to Products and open the product that matches your Maker project\
2\. Scroll down to the Metafields section at the bottom of the product page\
3\. Find the `maker.faq_schema` field you just created\
4\. Paste the full JSON-LD schema content into that field\
5\. Save the product

Repeat this for each product you want to add schema to.<br>

**Step 3: Add the metafield output to your product template**

This step only needs to be done once. Your developer will add a single line to your product template that outputs whatever schema is stored in that product’s metafield.\
1\. In Shopify admin, go to Online Store > Themes > Actions > Edit Code\
2\. Open your product template (usually `sections/main-product.liquid` or `templates/product.liquid`)\
3\. Add the following snippet anywhere in the file, ideally near the top or bottom of the main content section:

```
{% if product.metafields.maker.faq_schema != blank %}
  <script type="application/ld+json">
    {{ product.metafields.maker.faq_schema | raw }}
  </script>
{% endif %}
```

4\. Save the file\
From this point on, whenever a product has a schema stored in its `maker.faq_schema` metafield, it will automatically output in the page HTML for that product. Products without a metafield value will simply output nothing.<br>

**Step 4: Verify**

Go to your live product page, right-click, and select View Page Source. Search for `FAQPage`. If it appears in the raw HTML, the schema is live. You can also test it at <https://search.google.com/test/rich-results>.

***

### BigCommerce

BigCommerce’s Stencil framework also renders server-side. The approach here uses custom product fields.<br>

**Step 1: Enable custom fields on your product**

1\. In your BigCommerce admin, go to Products and open the product that matches your Maker project\
2\. Scroll to the Custom Fields section\
3\. Add a new custom field:\
Name: `maker_faq_schema`\
Value: paste the full JSON-LD schema content from Maker AI\
4\. Save the product\
Repeat for each product.<br>

**Step 2: Output the custom field in your product template**

1\. In your BigCommerce admin, go to Storefront > My Themes > Advanced > Edit Theme Files\
2\. Open `templates/pages/product.html`\
3\. Add the following snippet:

```
{{#each product.custom_fields}}
  {{#if (equals name "maker_faq_schema")}}
    <script type="application/ld+json">
      {{{value}}}
    </script>
  {{/if}}
{{/each}}
```

**Step 4: Save and push your theme** **and** **verify**

Go to your live product page, right-click, and select View Page Source. Search for `FAQPage`. If it appears in the raw HTML, the schema is live. You can also test it at <https://search.google.com/test/rich-results>.\
Verify\
Same as Shopify: View Page Source on a live product page and search for `FAQPage`.<br>

***

### **Magento (Adobe Commerce)**

In Magento, the equivalent of metafields is product attributes.<br>

**Step 1: Create a product attribute**\
1\. In your Magento admin, go to Stores > Attributes > Product\
2\. Click Add New Attribute\
3\. Set the attribute code to `maker_faq_schema`\
4\. Set the input type to Textarea\
5\. Under Storefront Properties, set Visible on Catalog Pages on Storefront to No (this is backend-only data)\
6\. Save the attribute and assign it to the relevant attribute set<br>

**Step 2: Add the schema to each product**

1\. Go to Catalog > Products and open the product that matches your Maker project\
2\. Find the `maker_faq_schema` attribute field\
3\. Paste the JSON-LD schema content from Maker AI\
4\. Save the product\
Repeat for each product.\
Step 3: Output the attribute in your product template\
In your product detail page template (`app/design/frontend/[Vendor]/[Theme]/Magento_Catalog/templates/product/view.phtml`), add:

```
<?php if ($product->getMakerFaqSchema()): ?>
<script type="application/ld+json">
  <?= $block->escapeHtml($product->getMakerFaqSchema()) ?>
</script>
<?php endif; ?>
```

Clear cache after saving:

```
php bin/magento cache:clean
```

### **Custom or Headless CMS**

If you’re on a custom-built platform or a headless setup, the concept is the same: store the schema against the product record in your database or CMS, then output it server-side in the product page template.\
For Next.js or React-based storefronts\
Store the schema in your product data (CMS, database, or API) and inject it using `next/head` at the page level, not inside a `useEffect`. This ensures it renders server-side:

```
import Head from 'next/head';

export default function ProductPage({ product }) {
  return (
    <>
      <Head>
        {product.makerFaqSchema && (
          <script
            type="application/ld+json"
            dangerouslySetInnerHTML={{ __html: product.makerFaqSchema }}
          />
        )}
      </Head>
      {/* rest of your page */}
    </>
  );
}
```

For any server-rendered platform (PHP, Python, Ruby, etc.)\
Store the schema in your product database field and output it in the template:

```
<?php if (!empty($product['maker_faq_schema'])): ?>
<script type="application/ld+json">
  <?= htmlspecialchars($product['maker_faq_schema'], ENT_NOQUOTES) ?>
</script>
<?php endif; ?>
```

***

### Schema URL instead of the downloaded file

If you prefer not to copy and paste schema content manually, Maker AI also provides a Schema URL for each project (available in the Publish Modal). This URL always serves the latest version of that product’s schema.<br>

**Note:** Shopify Liquid and most CMS templating languages cannot make external HTTP requests at render time. The Schema URL is most useful for developers building custom integrations, or for referencing and viewing the schema content without downloading the file. For Shopify, BigCommerce, and Magento, the recommended approach is to copy and paste the content into a metafield or custom attribute.

***

### Summary&#x20;

| Platform           | Where schema is stored | Template change needed |
| ------------------ | ---------------------- | ---------------------- |
| Shopify            | Product metafield      | Yes, one-time          |
| BigCommerce        | Product custom field   | Yes, one-time          |
| Magento            | Product attribute      | Yes, one-time          |
| Next.js / Headless | Product data / CMS     | Yes, one-time          |

The template change is always a one-time setup. Once it’s done, you only need to add or update the schema in the product record from now on.

***

### FAQs

<details>

<summary> <strong>What does "AI-ready" mean for a product page?</strong></summary>

It means your product detail page (PDP) has structured, machine-readable content that AI tools and search engines can interpret correctly. This includes things like schema markup, FAQs, and product data that's formatted in a way AI can actually use, not just read.

</details>

<details>

<summary><strong>What tool do I use to test this?</strong></summary>

Google's Rich Results Test is a free diagnostic tool that tells you whether your page's structured data is set up correctly enough to qualify for enhanced search features. Just go to [search.google.com/test/rich-results](https://search.google.com/test/rich-results), paste in your product page URL, and run the test. It will show you exactly what structured data Google can detect on that page.

It shows which rich result types were found on the page, as well as any errors or suggestions for your structured data. You'll see two types of flags: errors (critical, meaning the item won't qualify for rich results until fixed) and warnings (non-critical, meaning it can still show but might be incomplete). It's specifically Google-focused. You want to see valid items detected across those key categories, all green checkmarks. If you see orange "non-critical issues detected" flags, those are worth flagging to your dev or implementation team even if they don't break anything.For generic schema validation, you'd use the [Schema Markup Validator ](https://validator.schema.org/)to test all types of schema.org markup without Google-specific validation. So it won't catch every possible structured data issue, just the ones that matter for Google's rich results.&#x20;

<figure><img src="https://16034713-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FM2xSzN6C9hL2ozNM8Yx0%2Fuploads%2F37FBqg7XlzrNR62tKgjq%2Fimage%20(52).png?alt=media&#x26;token=0bdaba10-45d6-403e-9ab8-d00905bc6cbf" alt=""><figcaption></figcaption></figure>

</details>

<details>

<summary><strong>How does Rich Test Result connect to AEO?</strong></summary>

Rich results and AEO go hand in hand. If your structured data passes this test, it means Google and the AI tools that pull from Google's index can read and interpret your content correctly. A page without FAQ schema, for example, won't show up as a direct answer in AI-generated results the way a properly marked-up page will.

</details>

<details>

<summary><strong>I ran a test, but what if I don't see an FAQ in the results?</strong></summary>

That means your page either doesn't have an FAQ section or the one you have isn't marked up with proper schema. This is one of the quickest wins for AEO because FAQ schema helps AI tools surface your content as a direct answer, not just a link.

</details>

<details>

<summary><strong>Can Maker help with this?</strong></summary>

Yes. With Maker, all we need is a product URL. We'll generate the right questions, draft on-brand answers, and deliver FAQs that are built in a structured, machine-readable way, so they're AEO ready right out of the box. Your team just reviews and approves.

</details>