Adding schema markup to Squarespace takes one decision and one paste. Decide whether the markup describes every page or only one, then put a single JSON-LD block in the matching Code Injection field.

Squarespace already generates some structured data on its own, and it says that default markup cannot be edited or removed. Custom JSON-LD is the layer you control, so look at the public page source first and add only what is missing, once.

Before you paste, confirm your plan includes Code Injection. After you publish, test the public URL with Google's Rich Results Test and the Schema Markup Validator.

Key takeaways

  1. Check the source firstView the public page source for existing JSON-LD before pasting, because Squarespace says its automatic markup cannot be edited or removed.
  2. Pick one placementUse site-wide Header Code Injection only for entities that describe every page, and Page Header Code Injection for markup about a single page.
  3. Confirm plan and limitsSquarespace lists Core, Plus, Advanced and some legacy plans for Code Injection; checkout pages do not support it and Index landing pages do not show it.
  4. Paste once, then testPaste one valid block, publish, then test the public URL with Google's Rich Results Test and the Schema Markup Validator, not only the editor preview.
  5. Validation has limitsGoogle says valid markup only makes a page eligible for certain appearances; it does not guarantee a rich result, ranking, traffic or AI citation.

What Squarespace outputs automatically

Squarespace says it automatically generates structured data for blog posts, events, local businesses, organizations, products and websites, and that this markup cannot be edited or removed (Squarespace help article on search optimization, updated July 14, 2026). For products, Squarespace says the structured data can include the product name, image, description, price range, availability and product URL for Google product search features.

View the public page source to see exactly which schema.org types your own site outputs, and read it before you write any custom markup.

Keep three layers apart as you work. Schema.org is the vocabulary of types and properties, such as BlogPosting, Organization and Product. Google feature eligibility is Google's own list of requirements for a particular search display. Other consumers, including Bing, Apple, Yandex, DuckDuckGo, ChatGPT Search, Perplexity and Copilot, each have their own systems and documentation.

Choose site-wide or single-page injection

Site-wide injection suits only entities that truly describe every page, such as the organization behind the site. Open the Code Injection panel, paste valid HTML or scripts into the Header field and save. Squarespace inserts Header Code Injection into the <head> element of every page, so anything you put there repeats everywhere.

Page-specific injection suits markup about one article, one event or one product page. Squarespace says Page Header Code Injection is added to that page's <head>. The route is short:

  1. Open the Pages panel and hover over the target page.
  2. Select the gear icon, then Advanced.
  3. Paste the JSON-LD into Page Header Code Injection.
  4. Save and publish.

Blog settings also include a Post Blog Item Code Injection field that can add code to blog posts. Squarespace says its placement varies by site version and template, so confirm how it behaves on your own site before you rely on it. The worked example uses the page-level field on a single post.

Other builders put the same block in different places. The guides for WordPress, Shopify, Wix and Webflow cover those routes, and the general walkthrough in how to add schema markup covers the shared steps.

Confirm your plan and the pages Code Injection skips

Squarespace's Code Injection guide (updated September 16, 2026) says Code Injection is available on Core, Plus, Advanced and some legacy billing plans. Plan names and legacy availability can change, so check your current plan before you plan the work.

The same guide lists places where it does not apply. Checkout pages do not support Code Injection, and Index landing pages do not show it. Squarespace also warns that ordinary HTML in Page Header Code Injection can disappear when header transparency is turned off, so keep that field for the JSON-LD script and put visible content in the page's own blocks.

Squarespace adds that custom code can affect how a site looks or behaves, and that its support does not troubleshoot custom code. Keep a copy of every block you paste so you can restore it or remove it cleanly.

Inspect the page source before you paste

Open the live, public page in a browser, view its source and search for application/ld+json. Each match is a block of structured data. Write down the @type of every entity you find, such as BlogPosting, Organization, Product or BreadcrumbList, because that list tells you what is already described.

A man in a sage-green apron follows a long page on a laptop with a pencil at the front counter of a pottery studio
Figure 1. Reading the public page source for existing JSON-LD comes before any paste.

If Squarespace already outputs the correct entity, keep that default markup and add only information it lacks, and only if the information is accurate. Do not add a second version that contradicts the default output. If a custom block does describe the same entity, give it the same canonical URL, name and properties, and use a consistent @id, a stable identifier that is usually the canonical URL plus a fragment.

Test the public page rather than the editor preview, because the public source shows your injection together with everything else the page outputs.

Match properties to the type and the Google feature

Before you write the block, decide which type fits the visible content and which properties matter. "Required" and "recommended" belong to a named Google Search feature, not to schema.org validity in general. A property that Google does not require can still be valid schema.org vocabulary, and a type with no current Google feature is not invalid.

For a blog post, Google's Article documentation supports Article, NewsArticle and BlogPosting. It lists no required properties and recommends author, author.name, author.url, dateModified, datePublished, headline and image. Google's breadcrumb documentation asks for a BreadcrumbList with at least two ListItem objects, each with a position and a name, following a typical user path rather than a copy of the URL segments. The current page and the top-level domain are optional.

Organization has no required properties for Google, which says it can use organization markup on a homepage to understand and disambiguate an organization (Google Organization documentation). LocalBusiness requires name and address; the local business schema guide lists the recommended properties and the review restrictions.

Product requirements depend on whether the page targets merchant listings or product snippets, so use Google's Product documentation and test the specific product page. Squarespace already says it structures product information, which makes a source check especially important there.

FAQPage remains a valid schema.org type, but Google's documentation updates say the FAQ rich result stopped appearing in Google Search in May 2026 and the FAQ documentation was removed in June 2026 (Google documentation updates). Google also no longer shows how-to rich results (Google Search Central Blog, 2023). Add either type only where it accurately describes visible content, never as a Google display tactic.

Add BlogPosting and BreadcrumbList to one blog post

The example below describes one fictional blog post and its breadcrumb trail. Squarespace says it already generates markup for blog posts, so view the source first. If a correct BlogPosting is already there, paste only the BreadcrumbList object, keeping the surrounding @context and @graph. If the source shows no blog post markup, or you need properties the default lacks, paste both.

A blog post card with its top strip pulled out like a drawer holding two small bracket cards under a magnifier
Figure 2. The BlogPosting and BreadcrumbList block sits in the post's head, not in the visible page.
html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/blog/sample-guide/#article",
      "url": "https://example.com/blog/sample-guide/",
      "mainEntityOfPage": {
        "@type": "WebPage",
        "@id": "https://example.com/blog/sample-guide/"
      },
      "headline": "A Sample Guide for Website Owners",
      "description": "A fictional example article explaining a practical website task.",
      "image": ["https://example.com/images/sample-guide-16x9.jpg"],
      "datePublished": "2026-10-01T09:00:00-05:00",
      "dateModified": "2026-10-15T09:00:00-05:00",
      "author": {
        "@type": "Organization",
        "@id": "https://example.com/#organization",
        "name": "Example Learning Lab",
        "url": "https://example.com/"
      },
      "publisher": {
        "@type": "Organization",
        "@id": "https://example.com/#organization",
        "name": "Example Learning Lab",
        "url": "https://example.com/",
        "logo": {
          "@type": "ImageObject",
          "url": "https://example.com/images/example-learning-lab-logo.png"
        }
      }
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://example.com/blog/sample-guide/#breadcrumb",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com/" },
        { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://example.com/blog/" },
        { "@type": "ListItem", "position": 3, "name": "A Sample Guide for Website Owners", "item": "https://example.com/blog/sample-guide/" }
      ]
    }
  ]
}
</script>

Every value here is fictional, and every one must be replaced with something visible on your page. Set headline to the post's visible title and url and @id to its canonical address. Use a full image URL for the featured image. Write dates in ISO 8601 format with a time zone offset, use the published date shown on the page for datePublished, and include dateModified only when you actually update the post.

For the byline, the example credits an organization as both author and publisher. If the post carries a named writer, replace the author object with a Person that has a name and a url. Point the logo at your publisher logo, and make the breadcrumb names match the trail visitors see. If you would rather build the block than edit it by hand, Schema Nova's article schema generator and breadcrumb schema generator produce the same kind of JSON-LD from your own values. The related guides on article schema and breadcrumb schema explain each property.

JSON-LD must be valid JSON, so use straight quotation marks, separate entries with commas and leave no comma after the last entry. Paste the complete <script> element, including its opening and closing tags, into the Page Header Code Injection field for that post, then save and publish.

Setup steps for custom JSON-LD

  1. Choose the pageDecide whether the markup describes every page or one page, and confirm your plan includes Code Injection.
  2. Inspect existing markupView the public page source and note every existing JSON-LD type so the new block does not repeat it.
  3. Confirm visible factsCheck that the title, author or publisher, dates, image and breadcrumb trail appear on the page, then replace every example value.
  4. Paste and savePaste the complete script into the site-wide Header field or the page's Page Header Code Injection, then save and publish.
  5. Inspect the source againOpen the public URL, view its source and confirm the script appears once and no other injection repeats the entity.
  6. Run the validatorsTest the public URL with Rich Results Test and Schema Markup Validator, then use URL Inspection, Bing or Yandex checks where they matter.

Test the published page with each engine

Run the public URL through two Google tools that answer different questions. The Rich Results Test checks whether Google recognizes markup that can support a Google Search feature. The Schema Markup Validator checks schema.org vocabulary without limiting itself to Google features. Google recommends both for their different purposes (Google structured data testing guide). Schema Nova's schema checker can also check a block you paste, and the guide to replacing the old testing tool explains what each check covers.

After publishing or updating, use Google Search Console URL Inspection to see what Google can access. Confirm the page is indexable and is not blocked by robots.txt, a noindex directive, a login or a server control, then compare the rendered page with the JSON-LD and confirm that every marked-up fact is visible or clearly represented on the page.

Other engines have their own checks. Bing says it supports schema.org in JSON-LD, Microdata, RDFa, Microformats and Open Graph, and that markup can help it understand content without guaranteeing a visually rich result (Bing structured data guidance). Bing Webmaster Tools URL Inspection includes a Markup card that recognizes JSON-LD and reports issues found in the page source (Bing URL Inspection).

DuckDuckGo says it keeps its own crawler and indexes while most traditional links and images come from Bing (DuckDuckGo sources). Yandex Webmaster offers a structured data validator that supports schema.org, JSON-LD, Microdata, RDFa, Open Graph and microformats, and it says the validator also checks requirements for Yandex services (Yandex validator). Use it when Yandex traffic matters, and do not treat Google's required properties as Yandex requirements.

Apple's App Search Programming Guide says Applebot can index web content for Spotlight and Safari search results, recommends web markup and offers a validation tool for the data Applebot can extract (Apple documentation). For an ordinary Squarespace site, rely on crawlable HTML, visible content and valid JSON-LD.

Fix duplicate or conflicting markup

If the source shows two copies of the same entity, find where each one comes from. Check the site-wide Header field, the page's Header Code Injection, the blog post injection field and any integration that adds code to your pages. Look especially for repeated BlogPosting, Organization, Product, LocalBusiness, FAQPage or BreadcrumbList nodes.

Because Squarespace's automatic markup cannot be removed, the copy you remove is almost always your own. Delete the custom block, or trim it so it holds only the information the default output lacks. When two descriptions of the same entity must coexist, make their @id, canonical URL, name and shared properties match exactly, so one version never contradicts the other.

Keep the markup accurate while you edit. Do not mark up invented reviews, ratings, prices or locations, and do not describe content that visitors cannot see. Google's general structured data guidelines require markup to match visible page content, and they carry a manual action risk for markup that does not. The JSON-LD graph guide shows how separate nodes link to each other by @id when a page legitimately describes several entities.

Valid markup makes a page eligible for certain Google search appearances but does not guarantee one, and the same limit applies to rankings, traffic and citations in AI answers. Google says AI Overviews and AI Mode need no special markup and no AI-specific file, and still recommends structured data that matches visible text (Google AI features).

To be eligible for ChatGPT Search, OpenAI says a site should allow OAI-SearchBot to crawl it, and placement is not guaranteed (OpenAI). Perplexity documents PerplexityBot and Perplexity-User with robots.txt guidance (Perplexity crawlers), and Copilot Search uses Bing Search to ground some web answers (Microsoft Learn). So, keep important information in visible HTML text, add accurate JSON-LD that describes it, and allow the crawlers you want in robots.txt. See whether AI systems use schema markup.

Questions people ask

Does Squarespace add schema markup automatically?

Yes, according to Squarespace. It says it generates structured data for blog posts, events, local businesses, organizations, products and websites, and that this markup cannot be edited or removed. View the public page source to see the exact output on your own site.

Which Squarespace plans support Code Injection?

Squarespace's Code Injection guide lists Core, Plus, Advanced and some legacy billing plans. Plan names change, so confirm in your own account. Checkout pages do not support Code Injection, and Index landing pages do not show it.

Should custom schema go in the site header or the page header?

Use the site-wide Header field only for an entity that describes every page. For markup about one blog post, event or product page, use that page's Page Header Code Injection field, which Squarespace says is added to that page's head.

Does FAQ schema still produce Google rich results?

No general FAQ rich result is shown in Google Search any longer, based on Google's documentation updates, which date the change to May 2026. FAQPage is still a valid schema.org type, and the FAQ schema guide explains where it still fits.

Can I add LocalBusiness or Product schema to Squarespace?

You can paste either through Code Injection, but Squarespace says it already structures local businesses and products. Read the page source first. Google requires name and address for its local business feature, and the local business schema guide and product schema guide cover the details.

Quick check

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

Question 1 of 3

A JSON-LD block passes the Schema Markup Validator. What does that show?

Question 2 of 3

Where does markup about one blog post belong?

Question 3 of 3

What should you do before pasting a custom BlogPosting block?

Glossary

Select a term to see its definition.

Structured data. Information arranged in a standard format so software can interpret page entities and properties.