# OpenGraph product and price tags for AI agents

> OpenGraph meta tags (og:title, og:image, og:url, og:type) plus price tags (product:price:amount and product:price:currency, or og:price:*) give AI agents, chat apps and link previews a lightweight summary of a product page. They're a fallback signal when Product JSON-LD is missing, so this check carries low weight.

- Source: https://is-agentic-storefront.com/checks/opengraph-product
- Updated: 2026-10-15
- Category: Product data (25% of score)
- Impact: Low
- Spec: [Open Graph protocol](https://ogp.me/)
- Scanner check: OpenGraph product and price tags

## Why OpenGraph tags matter for AI agents

OpenGraph tags sit in the `<head>` and summarize a page in a few key-value pairs. They were designed for link previews, and they're still what chat apps, messaging tools and many agent "fetch" tools read first, because they're small and predictable.

For a product page, the useful set is the core [Open Graph protocol](https://ogp.me/) tags (`og:title`, `og:image`, `og:url`, `og:type`) plus a price. The core protocol has no product type, so price tags are de facto extensions: `product:price:amount` / `product:price:currency` from Meta's catalog conventions, and `og:price:amount` / `og:price:currency` as output by some ecommerce themes.

These tags are a fallback. [Product JSON-LD](https://is-agentic-storefront.com/checks/product-json-ld) is richer and is what Google Shopping and ChatGPT shopping rely on, which is why this check has the lowest weight in the product data category. But when JSON-LD is missing or broken, OpenGraph price tags are often the only machine-readable price an agent can find. In our research, a large store on a hosted platform had no JSON-LD in its raw HTML but did have OpenGraph price tags.

## What the scanner checks

The scanner reads the `<head>` of the first sampled product page. Tags are matched on either the `property` or the `name` attribute.

- **Basic tags**: `og:title`, `og:image`, `og:url`, `og:type` (any value).
- **Price tags**: an amount (`product:price:amount` or `og:price:amount`) **and** a currency (`product:price:currency` or `og:price:currency`).

| Result       | Condition                                                                   |
| ------------ | --------------------------------------------------------------------------- |
| Pass         | All four basic tags and a price amount with currency.                       |
| Partial      | At least one basic tag is present, but a basic tag or the price is missing. |
| Fail         | None of the four basic tags are present (price tags alone don't count).     |
| Inconclusive | No product page could be fetched.                                           |

The scanner also uses these price tags in [server-rendered product facts](https://is-agentic-storefront.com/checks/ssr-product-facts) when there's no JSON-LD price.

## How to add OpenGraph product tags

Render these in the server HTML `<head>` of every product page:

```html
<meta property="og:type" content="product" />
<meta property="og:title" content="Merino Crew Sweater" />
<meta property="og:description" content="Midweight merino wool crew neck sweater." />
<meta property="og:url" content="https://your-store.com/products/merino-crew" />
<meta property="og:image" content="https://your-store.com/images/merino-crew.jpg" />
<meta property="product:price:amount" content="89.00" />
<meta property="product:price:currency" content="USD" />
<meta property="og:price:amount" content="89.00" />
<meta property="og:price:currency" content="USD" />
<meta property="product:availability" content="in stock" />
```

Guidelines:

1. **Use absolute URLs** for `og:image` and `og:url`, and make `og:url` the canonical URL.
2. **Use a plain number** for the amount (`89.00`) and an ISO 4217 code for the currency.
3. **Generate from the same data** as the visible price and the JSON-LD, so all three agree.

Verify by viewing the page source and searching for `og:` and `price:`.

## How to fix it on Medusa

- **What the starter does**: the [DTC starter](https://github.com/medusajs/dtc-starter) storefront's product page sets `og:title` and `og:image` in `generateMetadata`, but no `og:url`, `og:type` or price tags.
- **What to add** (works for any Next.js storefront): return the tags from `generateMetadata` on the product route. `openGraph` covers title, description, URL and images. Next.js's `openGraph.type` has no `product` value, so put `og:type` and the price tags in `other`:

  ```ts
  export async function generateMetadata({ params }) {
    const product = await getProduct((await params).handle);
    return {
      openGraph: {
        title: product.title,
        description: product.description,
        url: `https://your-store.com/products/${product.handle}`,
        images: [product.thumbnail],
      },
      other: {
        'og:type': 'product',
        'product:price:amount': product.price.toFixed(2),
        'product:price:currency': product.currency.toUpperCase(),
      },
    };
  }
  ```

  `other` renders `<meta name="…">` rather than `property`. This scanner accepts both; some link-preview consumers expect `property`.

## Common mistakes

- `og:image` as a relative path, which most consumers can't resolve.
- `og:url` pointing at a variant or tracking URL instead of the canonical URL.
- A price with a currency symbol (`$89.00`) in the amount tag.
- Tags injected client-side by a tag manager, so they're missing from the raw HTML.

## Sources

- [The Open Graph protocol](https://ogp.me/)
- [Meta: web crawlers and sharing](https://developers.facebook.com/docs/sharing/webmasters/web-crawlers/)
- [Next.js: generateMetadata](https://nextjs.org/docs/app/api-reference/functions/generate-metadata)

## Frequently asked questions

### Is og:type product part of the Open Graph standard?

No. The core Open Graph protocol defines no product type. product:price:* (used by Meta catalogs) and og:price:* (output by some ecommerce themes) are de facto extensions that many consumers read anyway.

### Do I need OpenGraph tags if I already have Product JSON-LD?

JSON-LD matters more for agents. OpenGraph tags are cheap to add, power link previews in chat apps, and give agents a second, simpler source for the price.

### Should I use product:price or og:price tags?

Either passes this check. Outputting both is harmless and covers more consumers.

## Run your store on a platform built for agentic commerce

Medusa is open-source, headless commerce with a full Store API agents can call and storefronts you control end to end.

### Deploy on Medusa Cloud

Open-source commerce with a full Store API, hosted and scaled for you. Your storefront, your data model.

- [Deploy on Medusa Cloud](https://cloud.medusajs.com?utm_source=agent-friendly-scorer&utm_medium=referral&utm_campaign=markdown-cta&utm_content=%2Fchecks%2Fopengraph-product)
- [Medusa Cloud docs](https://docs.medusajs.com/cloud?utm_source=agent-friendly-scorer&utm_medium=referral&utm_campaign=markdown-cta&utm_content=%2Fchecks%2Fopengraph-product)

### Storefront skills for coding agents

Teach Claude Code, Cursor or Codex to build storefronts with the patterns these checks look for.

```bash
npx skills add medusajs/medusa-agent-skills
```

[View the skill on GitHub](https://github.com/medusajs/medusa-agent-skills/tree/main/plugins/ecommerce-storefront/skills/storefront-best-practices)

---

Scan your store for free at https://is-agentic-storefront.com/