Free tier · no payment method required

Product offers API

Get seller offers using exactly one identifier: ASIN, URL, or GTIN. Call one documented GET endpoint across 13 Amazon marketplaces with the same API key, normalized response envelope, and production metadata.

Get an API key View Documentation

TL;DR

The Product offers API returns structured JSON under data.amazonProduct. It is available through REST, GraphQL, and MCP, with a 5 min cache policy and explicit request, freshness, rate-limit, and usage metadata.

Use this Glade operation through

REST API GraphQL MCP and agent Skill

Live demo

Try the Product offers API in your browser

Run the allowlisted product offers preset against the real Glade backend. Parameters are predefined and validated before an upstream request is made.

Try the Product offers API

Run the predefined request before writing a single line

example response · ready

{
  "data": {
    "amazonProduct": {
      "offersPaginated": {
        "offers": [
          {
            "id": "offer_example",
            "price": {
              "value": 79.99,
              "currency": "USD",
              "display": "$79.99"
            },
            "conditionIsNew": true,
            "isPrime": true,
            "buyboxWinner": true
          }
        ],
        "pageInfo": {
          "currentPage": 1,
          "hasNextPage": false
        }
      }
    }
  }
}

Endpoint

What does the Product offers API return?

The Product offers operation is available through every Glade interface and resolves through the same validation and normalized output contract.

REST responseavailable

GET /api/amazon/product/offers returns data.amazonProduct in the standard response envelope.

GraphQL fieldavailable

amazonProductOffers exposes the same normalized operation through the typed GraphQL schema.

MCP toolavailable

get_amazon_product_offers exposes the allowlisted operation to compatible AI agents.

Developer First

How do you call the Product offers API in seconds?

Use /api/amazon/product/offers without maintaining marketplace-specific acquisition, parsers, retry rules, or response adapters.

One schema, every operation

Use this API alongside 16 other Glade operations without changing authentication or the response envelope.

Metadata, not guesswork

Every response includes request, cache, freshness, rate-limit, and usage metadata for production decisions.

See the contract before coding

Copy a request in Python, TypeScript, or cURL and inspect the example JSON before moving into production.

example response · ready

import requests

response = requests.get(
    'https://gladeapi.com/api/amazon/product/offers',
    params={'asin': 'B0D1XD1ZV3', 'domain': 'US', 'page': '1'},
    headers={'API-KEY': 'glade_live_YOUR_API_KEY'}
)
data = response.json()

[ .JSON ]

{
  "data": {
    "amazonProduct": {
      "offersPaginated": {
        "offers": [
          {
            "id": "offer_example",
            "price": {
              "value": 79.99,
              "currency": "USD",
              "display": "$79.99"
            },
            "conditionIsNew": true,
            "isPrime": true,
            "buyboxWinner": true
          }
        ],
        "pageInfo": {
          "currentPage": 1,
          "hasNextPage": false
        }
      }
    }
  }
}

Browse all 17 APIs

One API, 13 marketplaces

How does Glade normalize product offers across Amazon marketplaces?

Amazon storefronts vary by host, currency, locale, delivery context, and available fields. Glade keeps those differences behind one versioned product offers contract.

One schema, every marketplace

One documented contract.

13 Amazon storefronts use one marketplace code, validation layer, and output contract.

data.amazonProduct marketplace: US success: true

Currency and locale included

Context stays attached.

Marketplace, currency, delivery context, request ID, cache state, and fetch time travel with the normalized response.

cache: HIT fetched_at: 2026-08-16T12:00:00Z usage_units: 1

REST, GraphQL, and MCP

One key, every interface.

Keep one server-side API key while application code and agents use the interface that fits their workflow.

REST: /api/amazon/product/offers GraphQL: amazonProductOffers MCP: get_amazon_product_offers

Operation-level freshness

Caching fits the data.

This endpoint uses a 5 min cache policy so volatility and request cost stay explicit.

cache_ttl: 300 rate_limit: documented request_id: glade_...

Get an API key

Glade Amazon API17 endpoints supported

View docs

GET/api/amazon/product/offers?asin=B0D1XD1ZV3&domain=US&page=1

asinB0D1XD1ZV3domainUSpage1

curl 'https://gladeapi.com/api/amazon/product/offers?asin=B0D1XD1ZV3&domain=US&page=1' \
  -H 'API-KEY: glade_live_YOUR_API_KEY'

example response · ready

{
  "data": {
    "amazonProduct": {
      "offersPaginated": {
        "offers": [
          {
            "id": "offer_example",
            "price": {
              "value": 79.99,
              "currency": "USD",
              "display": "$79.99"
            },
            "conditionIsNew": true,
            "isPrime": true,
            "buyboxWinner": true
          }
        ],
        "pageInfo": {
          "currentPage": 1,
          "hasNextPage": false
        }
      }
    }
  }
}

Compare

How does Glade's Product offers API compare to a self-managed integration?

Glade packages product offers acquisition, validation, normalization, caching, errors, and request metadata behind one server-side key.

FeatureGlade APISelf managed

AuthenticationOne API-KEY headerSource-specific credentials or sessions

Setup requiredCreate a key and call the endpointBuild acquisition, parsing, retries, and adapters

Marketplace support13 stores through one contractSeparate host and locale handling

Response schemadata.amazonProductSource-specific page structures

Freshness5 min policy with metadataYour team owns caching and observation time

InterfacesREST, GraphQL, MCP, and SkillYour team maintains each adapter

How is Product offers API usage measured?

Successful normalized operations consume the units defined by the active plan. Request headers make usage and rate-limit state visible to your backend.

Can I use product offers data in production?

Use public data, respect source rules and third-party rights, keep keys server-side, and match retention and downstream processing to your approved use case.

FAQ

Have a question? We got answers

Answers about this Glade API, its parameters, interfaces, freshness, and production use.

How do I call the Product offers API?

Create a Glade key, send a GET request to /api/amazon/product/offers with one of the documented identifier or query presets, and read data.amazonProduct from the response envelope.

What does the Product offers API return?

Get seller offers using exactly one identifier: ASIN, URL, or GTIN. Optional fields remain optional, and every response includes request and freshness metadata needed for production handling.

Which marketplaces support product offers?

Use the same operation across 13 supported Amazon marketplaces by passing the documented domain code.

How fresh is product offers data?

This operation uses a 5 min cache policy. Read the cache-state and data-fetched-at headers instead of inferring freshness from when your application received the response.

Can I use the Product offers API with an AI agent?

Yes. The get_amazon_product_offers MCP tool and generated documentation expose the same allowlisted operation and validation rules.

Can I use the Product offers API in production?

Yes. Keep keys server-side, validate optional fields, store request IDs, use bounded retries for temporary failures, and review source rules and third-party rights for your use case.

Contract statistics

API contract at a glance

Current Product offers details generated from Glade's versioned operation catalog.

marketplaces

5 min

cache policy

interfaces

Ready to call the Product offers API?

Create a key, keep it server-side, and run the predefined request in minutes.

Get an API key