DataFeed Schema Generator — Express Dynamic Lists
Generate valid DataFeed JSON‑LD with DataFeedItem entries that include item URLs and last modified dates. Improve understanding of changing lists.
Why many feeds underperform
Pain points we solve
- Dynamic lists aren’t modeled as DataFeed/DataFeedItem, losing freshness context.
- Items don’t link to crawlable URLs or lack names.
- dateModified is missing, so update cadence is unclear.
- Manual JSON‑LD is inconsistent across feed endpoints.
How SwiftSchema helps
Solution
The DataFeed generator structures your feed using DataFeedItem entries, each with an item (a Thing with a name and URL) and an optional dateModified to signal freshness.
It produces copy‑ready JSON‑LD with feed‑level name/description/url so endpoints are clear and consistent.
How it works
How it works
- Choose DataFeed in the generator below.
- Enter feed name, description, and canonical feed URL.
- Add DataFeedItem entries with item names and absolute URLs; include dateModified to capture freshness.
- Copy JSON or Script, paste at your feed endpoint page, and validate in the Rich Results Test.
Paste once per feed endpoint. Validate. Ship.
What is DataFeed structured data?
DataFeed models machine-readable lists—latest products, press releases, job postings, articles, or offers. Each feed contains DataFeedItem objects referencing the actual items (via
item
) and, ideally, dateModified
timestamps. This schema helps search engines and downstream consumers understand that the list is dynamic, track freshness, and tie items back to canonical URLs. Use it on feed landing pages (e.g., /feeds/latest-products
) or API documentation pages that expose structured updates.
Essential properties
- @type: DataFeed— the wrapper object.
- name,description,url— describe the feed and link to the endpoint.
- dataFeedElement— array of DataFeedItem entries.
- DataFeedItemfields:
- @type: DataFeedItem
- dateModified— ISO 8601 timestamp for the item’s last update.
- item— the referenced entity (Thing/Product/Article/etc.) withname,url, and optionally@id.
- license— optional; specify licensing terms if the feed is reusable.
- creatororprovider— optional; note who maintains the feed.
- numberOfItems— total items available if paginating or summarizing.
- inLanguage— locale of the feed content if localized.
Content prep checklist
- Determine which feeds you want to expose (new products, changelog, top articles).
- List the canonical URLs and titles of the items you’ll include.
- Track last modified timestamps for each item (CMS publish date, Git commit date).
- Decide on pagination strategy (how many items per feed page).
- Document feed update cadence (daily, hourly) so you can keep schema current.
Implementation workflow
- Create/identify the feed page (or embed in the <head>of the feed endpoint).
- Generate DataFeed JSON‑LD with name,description,url, anddataFeedElemententries.
- Populate each DataFeedItem with itemreferencing the canonical URL and a descriptive name; includedateModified.
- Embed the schema on the feed page. If you expose feeds via API/JSON endpoints, you can output the schema in the response as well.
- Validate using Rich Results Test or Schema Markup Validator.
- Automate updates if the feed is generated programmatically (e.g., use your CMS to output JSON‑LD along with HTML).
- Paginate carefully: if paginating, include numberOfItemsand keep positions/dates aligned per page; ensure canonical/prev/next links are correct.
Linking DataFeed to other schema
- Each itemshould have its own schema on the destination page (Product, Article, Event). The DataFeed simply links to them.
- Use @idto reference items consistently across feeds and detail pages.
- Combine DataFeed with CollectionPage/ItemList when you have both a human-facing listing and a machine-readable feed.
Pagination and automation
- For large feeds, paginate the HTML page and indicate the total items via numberOfItems.
- Include only the items visible on the current page, or provide separate feed endpoints per page (with canonical tags).
- Automate JSON‑LD generation via build scripts or server-side rendering to prevent manual drift.
- Keep feed size reasonable; if you have thousands of items, provide summary feeds (latest 100) instead of listing everything.
- If you expose multiple locales, use localized URLs and set inLanguage; ensure hreflang/canonicals line up with feed URLs.
Troubleshooting checklist
- Missing itemdetails: ensure each DataFeedItem includesitem.nameanditem.url.
- No dateModified: add timestamps to signal freshness. Pull from CMS publish dates if needed.
- Relative URLs: convert to absolute canonical URLs.
- Stale feeds: schedule updates or hook into CMS publish events to regenerate JSON‑LD.
- Unstructured endpoints: if your feed is JSON-only, add a simple HTML wrapper page with the schema to improve discoverability.
- Broken items: periodically crawl item URLs; remove or fix entries that 404 or redirect improperly.
Maintenance tips
- Document feed ownership and update cadence so engineering/marketing teams know when to refresh the schema.
- Log feed generation events; monitor for failures that might leave schema stale.
- If you deprecate a feed, remove the DataFeed schema and redirect the endpoint to avoid confusion.
- Use monitoring to ensure item URLs return 200 OK; remove items that go 404.
On-page parity and QA checklist
- The items shown/linked on the feed page match dataFeedElemententries (names, URLs, order if relevant).
- dateModifiedvalues reflect the actual last update time from your CMS or source of truth.
- Feed urlis canonical and matches the page/endpoint where the schema lives.
- Item URLs are absolute HTTPS and resolve with 200 OK (no auth required).
- If localized, inLanguageand hreflang/canonicals align with the feed URL and items.
- Only one DataFeed block per feed page; avoid duplicates from plugins.
Validation routine
- Run Rich Results Test/Schema Markup Validator after template changes or feed code changes.
- Spot-check a few item URLs for correctness and live status after each deploy.
- For automated feeds, add a unit test or CI check to ensure JSON-LD is valid JSON and includes at least one DataFeedItem.
- Crawl feeds monthly to detect stale dateModifiedvalues or broken links.
Common mistakes to avoid
- Leaving out dateModified: hurts freshness signals. Always include when possible.
- Using relative or tracking URLs: stick to clean, absolute canonicals for item.
- Omitting item @type: set a concrete type (Product, Article, Event) instead of a generic Thing when you can.
- Massive inline feeds: keep HTML JSON-LD lean; offer API feeds for bulk access.
- Stale or duplicate items: prune old entries if they’re no longer part of the feed; keep lists deduped.
Required properties
dataFeedElement
Recommended properties
nameurldescriptionlicenseprovider.name
Minimal JSON-LD
{
"@context": "https://schema.org",
"@type": "DataFeed",
"name": "Latest Products",
"dataFeedElement": [
{
"@type": "DataFeedItem",
"dateModified": "2025-10-20",
"item": {
"@type": "Thing",
"name": "Anvil",
"url": "https://example.com/anvil"
}
}
]
}FAQs
What should item be?Show
Use a Thing with name and url, or your specific type (Product, Article, etc.).
How many items?Show
Include the items visible or relevant to the feed endpoint. Paginate as needed.