SwiftSchema Logo

    SwiftSchema

    Intuitive Schema Generation at Your Fingertips

    AboutLearnContact

    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.

    Try the DataFeed Generator

    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

    1. Choose DataFeed in the generator below.
    2. Enter feed name, description, and canonical feed URL.
    3. Add DataFeedItem entries with item names and absolute URLs; include dateModified to capture freshness.
    4. Copy JSON or Script, paste at your feed endpoint page, and validate in the Rich Results Test.
    Generate DataFeed JSON‑LD

    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

    1. @type: DataFeed
       — the wrapper object.
    2. name
      ,
      description
      ,
      url
       — describe the feed and link to the endpoint.
    3. dataFeedElement
       — array of DataFeedItem entries.
    4. DataFeedItem
      fields:
      • @type: DataFeedItem
      • dateModified
        — ISO 8601 timestamp for the item’s last update.
      • item
        — the referenced entity (Thing/Product/Article/etc.) with
        name
        ,
        url
        , and optionally
        @id
        .
    5. license
       — optional; specify licensing terms if the feed is reusable.
    6. creator
       or
      provider
      — optional; note who maintains the feed.

    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

    1. Create/identify the feed page (or embed in the
      <head>
      of the feed endpoint).
    2. Generate DataFeed JSON‑LD with
      name
      ,
      description
      ,
      url
      , and
      dataFeedElement
      entries.
    3. Populate each DataFeedItem with
      item
      referencing the canonical URL and a descriptive name; include
      dateModified
      .
    4. 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.
    5. Validate using Rich Results Test or Schema Markup Validator.
    6. Automate updates if the feed is generated programmatically (e.g., use your CMS to output JSON‑LD along with HTML).

    Linking DataFeed to other schema

    • Each
      item
      should have its own schema on the destination page (Product, Article, Event). The DataFeed simply links to them.
    • Use
      @id
      to 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.

    Troubleshooting checklist

    • Missing
      item
      details:       ensure each DataFeedItem includes
      item.name
      and
      item.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.

    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.

    Required properties

    • dataFeedElement

    Recommended properties

    • name
    • url
    • description
    Minimal JSON-LD
    Validate
    {
  "@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.

    Related types

    Browse all schema types

    References

    Generate Data Feed schema

    Fill in page details, copy JSON or Script, and validate.

      Schema Type

      🗃️ Data Feed Schema Generator

      Publish feeds of items with DataFeed and DataFeedItem, including item URLs and last modified dates.

      Generated Schema

      Validate your schema here.