To add Schema.org markup to a heritage collection, emit JSON-LD describing each item as a CreativeWork subtype (Photograph, Manuscript, Book), the collection as a CollectionPage, and the digital surrogate as an ImageObject. When search engines ignore it, the cause is almost always one of three things: invalid JSON-LD, marked-up content that is not visible on the page, or missing required properties. Run the page through Google's Rich Results Test and the Schema Markup Validator to see the exact error before changing anything.

Why is Google ignoring my markup?

Diagnose, do not guess. Three checks in order:

1. Is it valid? Paste the URL into validator.schema.org. A single trailing comma or unescaped quote invalidates the whole block.
2. Is the content visible? Schema.org must describe what a human sees on the page. Marking up a title that is hidden or absent is a policy violation Google will drop.
3. Are required properties present? A CreativeWork with no name is effectively invisible to parsers.

{
  "@context": "https://schema.org",
  "@type": "Photograph",
  "name": "High Street, Market Town, 1923",
  "creator": { "@type": "Person", "name": "A. Photographer" },
  "dateCreated": "1923",
  "description": "Gelatin silver print of the high street looking north.",
  "license": "http://rightsstatements.org/vocab/NoC-US/1.0/",
  "image": {
    "@type": "ImageObject",
    "contentUrl": "https://example.org/iiif/bv001/full/max/0/default.jpg"
  },
  "isPartOf": { "@type": "Collection", "name": "Market Town Photographs" }
}

Why does the validator say "no eligible items"?

This confuses people constantly, so separate two things:

• Valid markup means Schema.org parsed without errors — good.
• Eligible for a rich result means the type can trigger a visual snippet in search.

CreativeWork and its heritage subtypes are valid but rarely eligible for a rich result, so "no eligible items detected" is often normal and not a bug. Your markup is still indexed and still helps machines understand the item; it just will not draw a star-rating-style snippet. Use the Schema Markup Validator (not only the Rich Results Test) to confirm the markup itself is fine.

How do I map my existing Dublin Core to Schema.org?

Most of the crosswalk is mechanical. The judgement calls are few:

Dublin Core	Schema.org	Notes
dc:title	name	direct
dc:creator	creator	wrap as Person/Organization
dc:date	dateCreated	use ISO 8601; EDTF approximations need trimming
dc:description	description	direct
dc:subject	keywords or about	about if you can supply a URI
dc:rights	license	use a rightsstatements.org or CC URI
dc:type	@type	choose the closest CreativeWork subtype
dc:identifier	identifier / url	direct

The one trap: dateCreated wants clean ISO 8601, so an EDTF value like 1923~ ("approximately") must be reduced to 1923 or moved into description.

Why is my collection-level markup wrong?

A frequent error is marking every item page as a Collection instead of nesting items inside one. Get the part–whole relationship right:

• The collection landing page is a CollectionPage containing a Collection.
• Each item is a CreativeWork subtype with isPartOf pointing back to the collection.
• Optionally the collection lists items with hasPart.

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Market Town Photographs",
  "hasPart": [
    { "@type": "Photograph", "name": "High Street, 1923", "url": "https://example.org/bv001" },
    { "@type": "Photograph", "name": "Market Square, 1925", "url": "https://example.org/bv002" }
  ]
}

How do I roll this out across thousands of items without hand-coding?

Generate, never type. Render one JSON-LD block per item from your existing metadata and validate a sample programmatically:

import json, requests

def to_jsonld(rec):
    return {
        "@context": "https://schema.org",
        "@type": rec.get("schema_type", "CreativeWork"),
        "name": rec["title"],
        "dateCreated": rec["date"][:4],
        "license": rec["rights_uri"],
        "isPartOf": {"@type": "Collection", "name": rec["collection"]},
    }

# spot-check 20 generated blocks against the validator API
for rec in sample[:20]:
    block = to_jsonld(rec)
    assert block["name"] and block["license"], rec["id"]
    print(json.dumps(block))

Inject the block into each item template, deploy, then re-test a handful of live URLs.

Key Takeaways

• Use JSON-LD, CreativeWork subtypes for items, CollectionPage/Collection for the whole, ImageObject for surrogates.
• When markup is "ignored", check validity, visibility of the content, and required properties — in that order.
• "No eligible items" is usually normal for heritage types; valid markup still helps machines even without a rich snippet.
• The Dublin Core to Schema.org crosswalk is mostly mechanical; watch dateCreated needing clean ISO 8601.
• Nest items with isPartOf/hasPart instead of marking every page as a Collection.
• Generate JSON-LD from existing metadata in templates and validate a sample rather than hand-coding.

Frequently Asked Questions

Which Schema.org types should heritage collections use?

Use CreativeWork or its subtypes (Photograph, Book, Manuscript, VisualArtwork) for items, CollectionPage or Collection for the collection, and ImageObject for the digital surrogate. Wrap a collection's items with hasPart or isPartOf.

Should I use JSON-LD or Microdata for Schema.org?

Use JSON-LD. Google recommends it, it sits in a single script block separate from your HTML, and it is far easier to generate and validate than inline Microdata or RDFa.

Why is Google ignoring my Schema.org markup?

Usually because the markup is invalid, the marked-up content is not visible on the page, or required properties are missing. Run the URL through the Rich Results Test and Schema Markup Validator to see the exact parse errors.

Why does the Rich Results Test say my markup has no eligible items?

Schema.org markup is valid but not every type is eligible for a rich result. CreativeWork rarely triggers a visual rich snippet, so "no eligible items" can be normal even when the markup is correct and being indexed.

How do I add Schema.org to thousands of collection items?

Generate the JSON-LD from your existing metadata in a template, mapping Dublin Core fields to Schema.org properties. Inject one script block per item page rather than hand-coding, and validate a sample programmatically.

Can I map Dublin Core directly to Schema.org?

Largely yes: dc:title maps to name, dc:creator to creator, dc:date to dateCreated, dc:description to description and dc:rights to license. A few fields need judgement, but the core crosswalk is straightforward.

Related reading

• Make your metadata LOD-friendly
• Crosswalk between schemas
• Map MARC to Dublin Core
• Record rights in metadata
• Introduction to linked open data for heritage