Amazon ASIN API Guide: Get Product Data from an ASIN

What is an Amazon ASIN API?

An Amazon ASIN API accepts an Amazon Standard Identification Number and returns structured product data. Amazon describes an ASIN as the unique identifier for an item in its catalog. In practice, developers use an ASIN lookup API to turn a product link or identifier into fields such as the title, brand, images, price, availability, rating, feature bullets, and category path.

The important detail is that an ASIN is not a complete lookup by itself. Product content, offers, currency, availability, and even whether an item is listed can vary by Amazon marketplace. A production request should therefore contain both an ASIN and a marketplace.

This guide uses Glade API for the working examples. Glade is an independent developer API, not an Amazon service. If you are building an affiliate experience, a seller application, or an Amazon Business purchasing integration, review the official Amazon options later in this guide before choosing an API.

The shortest working ASIN lookup

Create a key in the Glade dashboard, keep it on your server, and make a GET request to the product endpoint. The domain parameter selects the marketplace; US is the default.

export GLADE_API_KEY="glade_test_lookup_your_secret"

curl --request GET \
  "https://gladeapi.com/api/amazon/product?asin=B0D1XD1ZV3&domain=US" \
  --header "Accept: application/json" \
  --header "API-KEY: $GLADE_API_KEY"

A successful response places the normalized product under data.amazonProduct:

{
  "data": {
    "amazonProduct": {
      "asin": "B0D1XD1ZV3",
      "title": "...",
      "brand": "...",
      "price": {
        "value": 0,
        "currency": "USD",
        "display": "..."
      },
      "mainImageUrl": "...",
      "imageUrls": [],
      "rating": 0,
      "ratingsTotal": 0,
      "featureBullets": []
    }
  }
}

The values above illustrate the response shape, not a saved observation for that ASIN. Amazon data changes and some fields are optional. Your application should treat a missing field as unavailable rather than inventing a value or assuming an empty string.

Step 1: Validate and normalize the ASIN

Glade accepts a 10-character, case-insensitive ASIN containing letters and numbers. Normalize user input before using it as a cache key or sending it to the API:

function normalizeAsin(value) {
  const asin = value.trim().toUpperCase();

  if (!/^[A-Z0-9]{10}$/.test(asin)) {
    throw new TypeError("ASIN must contain exactly 10 letters or numbers");
  }

  return asin;
}

Format validation can reject obvious mistakes, but it cannot prove that a product exists in the selected marketplace. A well-formed ASIN can still return 404.

If your input is an Amazon product URL instead, the product endpoint also accepts a single url parameter. Do not send both asin and url; a lookup must have exactly one product identifier.

Step 2: Choose the marketplace deliberately

Glade uses short marketplace codes such as US, CA, UK, DE, and JP. The current API documentation lists all 13 supported marketplaces.

Do not infer a marketplace from the shopper's language alone. Prefer an explicit store selection, the Amazon hostname in a supplied URL, or a marketplace stored with the user's workflow. This matters because:

• The same ASIN can have different offers, prices, and availability in different stores.
• Currency follows the marketplace, not the caller's location.
• Titles and other catalog content may be localized.
• Some ASINs are listed in one marketplace but absent in another.

Store the marketplace alongside every observation. An ASIN without its marketplace is an ambiguous identifier for price monitoring, comparisons, and historical analysis.

Step 3: Call Glade from server-side JavaScript

The following Node.js function validates the input, sets a timeout, checks the API error envelope, and returns response metadata alongside the product:

const GLADE_ORIGIN = "https://gladeapi.com";

export async function getAmazonProduct({ asin, domain = "US" }) {
  const normalizedAsin = normalizeAsin(asin);
  const url = new URL("/api/amazon/product", GLADE_ORIGIN);
  url.searchParams.set("asin", normalizedAsin);
  url.searchParams.set("domain", domain.toUpperCase());

  const response = await fetch(url, {
    headers: {
      Accept: "application/json",
      "API-KEY": process.env.GLADE_API_KEY,
    },
    signal: AbortSignal.timeout(10_000),
  });

  const body = await response.json();

  if (!response.ok) {
    const problem = body.errors?.[0];
    const requestId = response.headers.get("x-request-id");
    throw new Error(
      `Glade ${response.status}: ${problem?.message ?? "Request failed"}` +
        (requestId ? ` (request ${requestId})` : ""),
    );
  }

  return {
    product: body.data.amazonProduct,
    metadata: {
      requestId: response.headers.get("x-request-id"),
      cache: response.headers.get("x-glade-cache"),
      fetchedAt: response.headers.get("x-glade-data-fetched-at"),
      usageUnits: Number(response.headers.get("x-glade-usage-units") ?? 0),
      rateLimit: Number(response.headers.get("x-ratelimit-limit")),
      rateRemaining: Number(response.headers.get("x-ratelimit-remaining")),
      rateReset: Number(response.headers.get("x-ratelimit-reset")),
    },
  };
}

Never expose the API key in browser JavaScript, a mobile binary, analytics, logs, or an error message. Put this function in your backend, server action, API route, worker, or other trusted runtime.

Step 4: Handle failures by category

Glade errors use a stable JSON shape with success: false and an errors array. Treat HTTP status codes differently:

• 400 means the request is invalid. Fix the ASIN, marketplace, or parameter; retrying the same input will not help.
• 401 means the key is missing, malformed, revoked, or otherwise unauthorized.
• 402 means the organization's current quota or billing entitlement does not allow the request.
• 404 means the endpoint or requested Amazon resource was not found.
• 429 means a rate, concurrency, or quota control rejected the request. Respect Retry-After when it is present.
• 502, 503, and 504 indicate a temporary provider, service, or timeout condition.

Retry only idempotent GET requests and only for temporary failures. Use exponential backoff with jitter, cap the number of attempts, and preserve the X-Request-Id when logging a failure. Do not retry validation errors, authentication failures, or missing products.

Step 5: Use freshness and rate metadata

Product data does not all age at the same speed. A title changes rarely; an offer can change between page views. Glade exposes X-Glade-Cache and X-Glade-Data-Fetched-At so your application can decide whether an observation is suitable for display, analysis, or an alert.

Glade also returns X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset. Use those headers to pace background work instead of waiting for a 429. A successful public operation reports its metered cost in X-Glade-Usage-Units; rejected and failed requests report zero units.

For a resilient integration:

• Cache responses by operation, normalized input, and marketplace—not ASIN alone.
• Store fetchedAt with any price or availability observation.
• Coalesce duplicate lookups when several users request the same product at once.
• Limit concurrency as well as requests per second.
• Keep the last known value separate from the latest fetch status so a temporary failure does not become a false price change.

Go beyond basic product details

Once you have the ASIN and marketplace, the same authentication and response conventions work across related Glade endpoints:

• /api/amazon/product/offers for seller and offer observations.
• /api/amazon/product/reviews for review pages and rating filters.
• /api/amazon/product/variants for size, color, and other variations.
• /api/amazon/product/gtin-from-asin for an associated GTIN when one is available.
• /api/amazon/product/stock and /api/amazon/product/sales for explicitly labeled estimates.

The REST reference documents the parameters and output for every operation. Keep estimated data labeled as an estimate in your own product; do not present it as an Amazon-provided fact.

Which official Amazon API can look up an ASIN?

Amazon has multiple official APIs, each attached to a particular business relationship:

Creators API for affiliate product experiences

Amazon's Creators API introduction documents a REST API for publishers, influencers, and affiliate partners. Its GetItems operation retrieves products by ASIN or other identifiers. Access requires Amazon Associates enrollment for the target marketplace and qualifying sales; the current documentation states at least 10 qualifying sales in the previous 30 days.

Choose Creators API when your application is fundamentally an Amazon Associates shopping or recommendation experience and you meet the program requirements.

Selling Partner API for seller and vendor software

Amazon's Catalog Items API has a getCatalogItem operation for an ASIN and marketplace. SP-API is intended for software serving Amazon sellers and vendors. Public applications use selling-partner OAuth authorization, while private applications are self-authorized, as described in Amazon's developer onboarding guide.

Choose SP-API when catalog lookup is part of a seller or vendor workflow such as listings, inventory, pricing, or order operations.

Amazon Business Product Search API for procurement

The Amazon Business Product Search API can retrieve product data by ASIN for Amazon Business customers. It requires Amazon Business API onboarding and the appropriate product catalog role.

Choose it when the product lookup belongs inside an Amazon Business purchasing or procurement experience.

Glade API for a normalized developer interface

Glade is useful when you need public Amazon product, search, offer, review, seller, category, deal, or bestseller data behind one API key without implementing seller OAuth. It offers REST, GraphQL, and MCP interfaces over the same normalized operation layer.

Glade is not a substitute for private seller data, order management, affiliate-program obligations, or Amazon Business consent. Use the official Amazon API whenever your workflow depends on those capabilities.

Production checklist

Before shipping an Amazon product lookup feature:

1. Keep the API key in a trusted server environment.
2. Validate and uppercase the ASIN.
3. Require or reliably derive a marketplace.
4. Treat optional response fields as optional.
5. Record the request ID and data fetch timestamp.
6. Retry only temporary failures with bounded backoff.
7. Pace jobs with the returned rate-limit headers.
8. Label stock and sales estimates clearly.
9. Review Amazon policies and third-party rights for how you display, cache, and redistribute product content.
10. Test with products that are unavailable, have variants, lack a visible price, and differ across marketplaces.

With those boundaries in place, an ASIN API becomes a dependable building block rather than a fragile page parser hidden inside your application.

References

• Amazon Creators API introduction
• Amazon Creators API registration requirements
• Amazon SP-API Catalog Items reference
• Amazon SP-API developer onboarding
• Amazon Business Product Search API reference
• Glade API documentation