Webflow gives you three routes for JSON-LD: the native Schema Markup field, a script in custom code, or a Code Embed on a CMS Collection template. For a Collection such as blog articles, use the Code Embed on the template, so one block describes every item.

On that template, add the Code Embed, connect each CMS field with the purple button Webflow provides, publish, and read the published page source. Then test several items, including ones with apostrophes, quotation marks, ampersands and accented letters, because a template that works for one item can break on another.

Key takeaways

  1. Three Webflow routesUse the native Schema Markup field, a JSON-LD script in custom code, or a Code Embed on a Collection template for item-level values.
  2. Template for CollectionsPlace one Code Embed on the Collection template, connect each CMS field with the purple button, then publish and read the published source.
  3. Plain fields for plain valuesUse plain-text, URL, image and ISO 8601 date fields. Keep Rich Text out of JSON strings, since quotes, line breaks and HTML can break the block.
  4. Test awkward itemsTest several real items, including apostrophes, quotation marks, ampersands and accented letters, and inspect the published source, not the Designer preview.
  5. Valid is not guaranteedValid markup can make a page eligible for some Google features, but it does not guarantee a rich result, traffic or an AI citation.
  6. FAQPage stays validFAQPage remains a valid Schema.org type, but Google stopped showing FAQ rich results from May 7, 2026, so a FAQ block will not produce one.

Choose the Webflow route that fits the page

Webflow supports JSON-LD in three practical places, and the right one depends on how many pages the markup describes. The native Schema Markup field outputs schema in the published page head, according to Webflow's schema markup help page. Custom code goes in site settings (before </head> or before </body>) or in an individual page's settings. A Code Embed can sit in a page layout or on a CMS Collection template.

Match the place to the job. Facts that never change from page to page, such as an Organization description, belong at the site level. A one-off page can take its own block in page settings. A Collection, where every item needs its own headline, dates and author, needs the Code Embed on the template so Webflow can fill in each item's values.

Webflow's custom code help page says custom code applies only after you publish, and it warns that custom code can conflict with platform functionality. Before you add anything, look at what the site already outputs. If the native field or an app already describes the same article, a second block describes the same item twice.

Pick a schema.org type that matches the visible page: BlogPosting for a blog article, Product for a product page, Event for an event, Organization for an organization page. The markup describes content that visitors can see; it never replaces it. If you build on another platform, the guides for WordPress, Shopify, Wix, Squarespace, HubSpot, Next.js and React and Google Tag Manager cover those routes.

Add static JSON-LD in custom code

A static block is the simplest case and a good way to learn the vocabulary before you bind fields. The example below describes one fictional article. Replace every value with facts that appear on your own page: the URLs, the headline, the description, the image addresses, the dates and the author. Keep the publisher details only if they match your site.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": "https://example.com/blog/sample-webflow-article#article",
  "url": "https://example.com/blog/sample-webflow-article",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/sample-webflow-article"
  },
  "headline": "A Sample Webflow Collection Article",
  "description": "A fictional article used to demonstrate JSON-LD on a Webflow CMS Collection page.",
  "image": [
    "https://example.com/images/sample-article-16x9.jpg",
    "https://example.com/images/sample-article-4x3.jpg",
    "https://example.com/images/sample-article-1x1.jpg"
  ],
  "datePublished": "2026-11-01T09:00:00-05:00",
  "dateModified": "2026-11-10T14:30:00-06:00",
  "author": {
    "@type": "Person",
    "name": "Alex Rivera",
    "url": "https://example.com/authors/alex-rivera"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Publishing",
    "url": "https://example.com",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/example-publishing-logo.png"
    }
  },
  "inLanguage": "en-US"
}
</script>

The script wrapper is what a custom-code area or Code Embed expects. The JSON between the tags is the markup itself, and every key in it is a schema.org property. Paste it into one page's settings and it describes that page only, which is exactly why it fails on a Collection: every item would carry the same headline.

For the native Schema Markup field, follow the format Webflow's help page describes for that field rather than assuming the script tags belong there. For more worked examples of other types, see the JSON-LD schema examples guide.

Decide which properties to fill

Before you build the template, decide which fields each item must have. Two different tests apply, and they are easy to mix up. Schema.org validity asks whether the type and properties are used correctly. A Google feature asks whether the page meets that one feature's documented requirements.

Google's Article structured data documentation (last updated September 8, 2026) lists author, author.name, author.url, dateModified, datePublished, headline and image as recommended properties. It lists no required properties for the Article feature, and it says to add the recommended ones that apply to the page. So, a CMS item with no modified date is not broken; it is simply missing one recommended property.

Breadcrumbs work differently. Google's Breadcrumb documentation (last updated September 8, 2026) marks itemListElement, position and name as required for that feature, and item as required on every entry except the final breadcrumb.

Add JSON-LD to a Collection template

The Collection template is the page Webflow reuses for every item in a Collection. Webflow's help page on CMS data in custom code embeds describes the workflow for connecting CMS fields inside a Code Embed, and its Collection pages help explains the template model. The steps are:

  1. Open the Collection page template (or a Collection list).
  2. Add a Code Embed, or select an existing one.
  3. Choose Edit code.
  4. Place the cursor where a CMS value should appear.
  5. Select the purple button that connects CMS fields.
  6. Choose the field that holds that value.
  7. Save and publish.

CMS fields can be connected when the Code Embed sits in a Collection list or on a Collection page. When the page renders, Webflow replaces each generated placeholder with that item's value. The result you care about is the published HTML: it must contain valid JSON-LD for each individual item.

A woman in a denim jacket holds a printed sheet of boxes joined by arrows and rests a hand on a laptop at a studio desk
Figure 1. Comparing the template layout with the published page shows whether each item received its own values.

Webflow generates the placeholder text itself, so insert every binding through the purple control instead of typing a token by hand. The template below uses readable stand-ins in capital letters, such as CMS_TITLE, so you can see where each field goes. These words are not Webflow syntax. In the Code Embed, select a stand-in, delete it, and insert the matching field with the purple button. The #article ending on @id is ordinary text typed after the bound canonical URL.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": "CMS_CANONICAL_URL#article",
  "url": "CMS_CANONICAL_URL",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "CMS_CANONICAL_URL"
  },
  "headline": "CMS_TITLE",
  "description": "CMS_SEO_DESCRIPTION",
  "image": "CMS_IMAGE_URL",
  "datePublished": "CMS_PUBLISHED_DATE",
  "dateModified": "CMS_UPDATED_DATE",
  "author": {
    "@type": "Person",
    "name": "CMS_AUTHOR_NAME",
    "url": "CMS_AUTHOR_PROFILE_URL"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Publishing",
    "url": "https://example.com",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/example-publishing-logo.png"
    }
  },
  "inLanguage": "en-US"
}
</script>

Map each stand-in to a field of the matching kind. url and @id take the canonical URL. headline takes a Plain Text title. description takes a Plain Text SEO description. image takes an image URL from an Image field. The two dates take Date/Time fields for published and updated. author.name takes a Plain Text author name, and author.url takes a URL field for the author's profile.

The publisher stays as fixed site-level data, typed once in the template, because every article comes from the same organization. Keep the JSON structure fixed and bind only fields that always hold a valid value; if some items have no updated date, remove dateModified from the template or make the field required in the Collection.

Setup steps for a Webflow Collection

  1. Choose the page typeA static page uses page settings or the native Schema Markup field. A CMS Collection page uses the Collection template.
  2. Add the blockAdd a Code Embed on the template, or use the schema field, then choose Edit code.
  3. Connect CMS fieldsPlace the cursor, select the purple button and choose each field. Keep the JSON structure fixed.
  4. Publish the siteCustom code applies only after publishing, so the Designer preview is not the final output.
  5. Inspect the published sourceOpen the live page source and confirm one valid JSON-LD object per block, with that item's values.
  6. Validate the resultRun the Schema Markup Validator, Google's Rich Results Test and Bing URL Inspection, then test a second item with punctuation.

Keep CMS values from breaking the JSON

A JSON string has strict rules, and CMS content does not follow them. A quotation mark, backslash, line break, HTML entity or closing script sequence inside a value can break the block. A headline such as The "Best" Mugs of the Year would produce this broken line when inserted raw:

text
"headline": "The "Best" Mugs of the Year"

The inner quotation marks end the string early, so a parser stops reading. In valid JSON, those marks must be escaped as \". Rich Text fields add a second problem, because they carry HTML tags and entities that do not belong inside a plain JSON string. Treat the block above as a teaching example only; never paste it into a page.

The safest defense is to choose the right field for each value and then test. These safeguards cover most breakage:

  • Use plain-text fields for headline, description and author name.
  • Use URL fields for links and profile addresses, and store absolute HTTPS URLs.
  • Use an Image field for images.
  • Store dates in ISO 8601 format, such as 2026-11-12 or 2026-11-12T09:30:00-06:00.
  • Write a separate plain-text summary instead of inserting unprocessed Rich Text.
  • Keep every value inside a JSON string unless the property expects an array or an object.

Use Webflow's binding control rather than copying raw values into several templates by hand, and confirm in the published source that each date appears in the ISO 8601 shape. Google's introduction to structured data says JSON-LD can sit in the head or the body and that Google can read JSON-LD inserted by JavaScript or CMS widgets. The rendered page still needs valid, accessible markup, so the checks below matter even when the template looks right.

Add breadcrumb markup to the same template

Breadcrumbs show where a page sits in the site, and the markup uses a separate type, BreadcrumbList. For a blog Collection, the trail is usually the blog index, then the current article. Only the last item can leave out item, because it is the page the visitor is already on. The example below is fictional; replace the blog name and address with your own, and bind the final name to the same title field.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Blog",
      "item": "https://example.com/blog"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "CMS_TITLE"
    }
  ]
}
</script>

Place it in the same Code Embed as a second script element, or give it a Code Embed of its own. The trail should match the breadcrumb links visitors can see on the page. For the full rules and more trails, read the breadcrumb schema guide, and for the article type in depth, read the article schema guide. The breadcrumb schema generator and article schema generator build the same shapes from a form.

Test the published page

Publish first, because custom code applies only after publishing. Then open the live page, view its source, and find the script blocks. The Designer preview is not enough; the published page must render the final JSON-LD. You should see one valid object per block, with the values for that particular item rather than stand-ins.

A template card linked to four page cards, three with check marks and one with a warning triangle and a magnifier
Figure 2. Testing several items catches the one whose field values break the block.

Next, test more than one item. Open an item with an apostrophe, one with quotation marks, one with an ampersand and one with accented letters. If a single item breaks while the others pass, the cause is almost always the value in one field. Paste the block into Schema Nova's schema validator to find the exact line that fails.

Different validators answer different questions. The Schema Markup Validator checks JSON and schema.org validity. Google's Rich Results Test checks eligibility for Google features, and Google Search Console URL Inspection shows how Google sees a published URL. Google's testing tools page describes the Rich Results Test and the Schema Markup Validator side by side. Bing Webmaster Tools offers URL Inspection, which can show detected JSON-LD in its Markup card.

A passing check means the markup parses and meets the requirements that tool covers. It does not mean any search engine will show a rich result.

Bing documents support for schema.org in JSON-LD, Microdata, RDFa, Open Graph and Microformats, so the Code Embed block serves Bing as well. DuckDuckGo says its traditional links come largely from Bing, per its help page on result sources. Yandex does not support every schema.org type (semantic markup FAQ), and its structured data validator applies Yandex-specific service requirements.

Microsoft says Copilot sends queries to Bing and uses Bing results to compose answers (Copilot web search documentation), so Bing's indexing matters there. For ChatGPT Search and Perplexity, keep the visible page clear, crawlable and accurate. See whether AI systems use schema markup.

Fix common Webflow schema problems

Most failures on Webflow fall into four patterns, and each has a short fix. Work through them in this order, since the first is the cheapest to rule out.

The block is missing from the published source

Custom code applies only after publishing, so start by publishing the site and reloading the live URL. Then confirm the Code Embed sits on the Collection template and not on a separate static page. A block that shows in the Designer but not in the live source usually means the change was never published.

One item breaks while the others pass

The cause is a value in that item's fields. Look for a quotation mark, a backslash, a line break, an HTML entity or Rich Text content in a field the template binds. Fix the field value, or switch the template to a plain-text field that you control.

The page has two blocks describing the same thing

If the native Schema Markup field, an app and a Code Embed all output a BlogPosting, the page describes one article three times. Keep one source for each type and remove the others. Then re-test the published page to confirm only one block remains.

A FAQ block shows no Google result

Google announced that FAQ rich results would stop appearing in Google Search starting May 7, 2026, and removed the FAQ documentation in June 2026, as recorded on its documentation updates page. FAQPage remains a valid schema.org type, so the markup is not wrong, but it is not a current Google Search rich-result feature. Do not add it only because a page contains questions. Where the visible FAQ helps readers, it stays useful on its own; read the FAQ schema guide for the type itself.

Questions people ask

Can Webflow CMS fields populate JSON-LD?

Yes. Webflow lets you connect CMS fields inside a Code Embed placed on a Collection page or in a Collection list, using the purple button in the code editor. Webflow replaces each connected placeholder with the item's value when the page renders.

Where should JSON-LD go in Webflow?

Use the native Schema Markup field or page or site custom code for static markup, and a Code Embed on the Collection template for item-level values. Google says JSON-LD may sit in the head or the body, so either works as long as the published page contains it.

Does valid schema guarantee a Google rich result or an AI citation?

No. Google says correctly implemented markup makes a page eligible for some features, not that it will display. Bing says structured data does not guarantee visibility or grounding traffic, and no markup guarantees an AI citation.

Is FAQ schema still a Google rich-result feature?

No. Google stopped showing FAQ rich results from May 7, 2026, and removed the documentation in June 2026. FAQPage is still part of the schema.org vocabulary, so existing markup stays valid.

Does Bing support JSON-LD?

Yes. Bing documents support for schema.org markup in JSON-LD, along with Microdata, RDFa, Open Graph and Microformats. Its URL Inspection tool has a Markup card that shows detected JSON-LD and markup issues.

Quick check

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

A Webflow CMS field contains a headline with quotation marks. What should happen before it is inserted into JSON-LD?

Question 2 of 3

The Schema Markup Validator passes. Does that guarantee a Google rich result?

Question 3 of 3

A page contains FAQ content. Does FAQPage automatically produce a Google FAQ rich result?

Glossary

Select a term to see its definition.

Structured data. Machine-readable information that describes page content.