Fixing Incorrect URLs in AI-Generated Schema

Where URLs hide in a generated block

It is easy to check url and forget the rest. These are the properties that hold addresses in the types generators most often produce, and what each one should point at.

The schema.org addresses used as values, such as https://schema.org/InStock, are fixed vocabulary terms. They are correct as written and do not need checking.

Why generated addresses go wrong

A language model does not browse your site. It is given the page's HTML or text and writes JSON-LD from it. Almost every URL fault traces back to something in that input, or to a gap the model filled.

• It was run on the wrong copy of the page. Generating from a staging host, a local preview, a page builder's preview link or a password-protected draft gives you markup full of addresses from that host.
• The address you gave it carried extras. A URL pasted from an email campaign or an ad keeps ?utm_source=, ?fbclid= or ?gclid=, and the model faithfully copies it into url and @id.
• The HTML used relative paths. Most sites write src="/images/boiler.jpg". The model copies the path as it found it, so the markup says "image": "/images/boiler.jpg".
• Lazy loading hid the real image. Many themes put a placeholder in src and the real file in data-src or srcset. The model may pick the placeholder, a tiny inline data: image or a 300-pixel thumbnail.
• It filled a gap with a pattern. Asked for an Organization with a logo and social profiles, a model can produce https://example.com/logo.png or https://www.facebook.com/brightwellheating because those shapes are common, not because they exist.
• The content is old. Posts written before a move to https, or before a domain change, still link with the old address, and the model repeats it.

Wrong and right, pattern by pattern

Addresses written with escaped slashes, such as https:\/\/www.example.co.uk\/about, are not an error. PHP's json_encode() writes them that way by default and every JSON parser reads them as ordinary slashes.

A corrected block

This is a generated Organization for a fictional heating firm after every address was corrected. The generator had written a relative logo path, a staging url and two guessed social profiles, one of which belonged to a different company.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://www.example.co.uk/#organization",
  "name": "Brightwell Heating",
  "url": "https://www.example.co.uk/",
  "logo": {
    "@type": "ImageObject",
    "url": "https://www.example.co.uk/assets/brightwell-logo-512.png",
    "width": 512,
    "height": 512
  },
  "image": "https://www.example.co.uk/assets/brightwell-van-1200x800.jpg",
  "sameAs": [
    "https://www.linkedin.com/company/example-brightwell-heating",
    "https://www.instagram.com/example_brightwell"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer service",
    "telephone": "+44 1632 960123",
    "url": "https://www.example.co.uk/contact"
  }
}
</script>

Note what was left out: the Facebook address the model suggested did not exist, so it went rather than being "fixed" to a guess of our own. A short sameAs list of real profiles is worth more than a long list with a dead entry.

Checking every address at once

Clicking through a dozen addresses by hand is slow and it is easy to miss the one in a nested object. This short Python script reads a generated block saved as a file, finds every string that looks like an address, and reports anything that is not absolute https, fails to load or redirects. It uses only the standard library.

import json, sys, urllib.request

def find_urls(node, path='$'):
    if isinstance(node, dict):
        for key, value in node.items():
            yield from find_urls(value, path + '.' + key)
    elif isinstance(node, list):
        for i, value in enumerate(node):
            yield from find_urls(value, '%s[%d]' % (path, i))
    elif isinstance(node, str) and node.startswith(('http', '/', 'data:')):
        yield path, node

block = json.load(open(sys.argv[1], encoding='utf-8'))
for path, url in find_urls(block):
    if url.startswith('https://schema.org/') or path.endswith('@context'):
        continue
    if not url.startswith('https://'):
        print('NOT ABSOLUTE HTTPS ', path, url)
        continue
    if path.endswith('@id'):
        continue
    req = urllib.request.Request(url, headers={'User-Agent': 'schema-url-check'})
    try:
        with urllib.request.urlopen(req, timeout=15) as r:
            moved = '' if r.geturl() == url else ' redirects to ' + r.geturl()
            print(r.status, path, url + moved)
    except Exception as err:
        print('FAILED', path, url, err)

Save the JSON without the script tags as block.json and run python3 check_urls.py block.json. Anything marked FAILED, NOT ABSOLUTE HTTPS or "redirects to" needs attention. A redirect usually means the canonical has a different host, scheme or trailing slash from the address in the markup.

The fix, step by step

Platform notes

WordPress

The site address comes from Settings, General, and old posts may still hold http:// links from before the site moved to https. Image uploads have size variants with names like -300x200.jpg; the generator can pick one of these from the post body, so check that image points at the original file. Staging copies made by hosting tools use a different host, so never generate from the staging site and copy the markup across.

Shopify

Liquid's image_url filter returns a protocol-relative address that starts with //cdn.shopify.com. If you template generated markup in Liquid, add | prepend: 'https:'. The storefront can also be reached on its .myshopify.com address; make sure markup uses your primary domain, which the canonical_url object gives you.

Custom and static sites, frameworks

Build the site origin from a single environment variable or config value, and join paths to it when the markup is rendered, so a staging build writes staging addresses and a production build writes live ones. Check the production build's output, not the dev server, because many frameworks rewrite asset paths with hashes at build time.

Keeping addresses right

• One origin, one place. Take the scheme and host from a single setting everywhere markup is produced.
• Generate from the canonical. Copy the address from the canonical tag, not the browser bar, before you run the generator.
• Keep @id values stable. Once an @id is published, leave it alone, even if the page title changes. Other blocks may refer to it.
• Recheck after moves. A domain change, an https switch or a new URL structure makes every stored address in pasted markup out of date. Search your stored blocks for the old host.
• Verify profiles once, then reuse them. Keep a short list of confirmed sameAs addresses and paste from that list rather than accepting generated ones.