Amazon ASIN Bulk Check via API in 2026

FBA sellers need to check which ASINs they are eligible to sell before committing to inventory. The manual process: browse Amazon categories, copy ASINs one by one, paste into Seller Central's add product page, and check for restrictions. A post on r/AmazonFBA described checking 1,449 ASINs this way. That is roughly 12 hours of copy-paste work. An API approach reduces this to minutes.

The Manual Approach and Why It Breaks

Scraping Amazon category pages to extract ASIN lists is the first step most sellers try to automate. The problems are well-known: Amazon's category pages are dynamically loaded, pagination is inconsistent, and aggressive bot detection blocks most scraping tools within a few hundred requests. Residential proxies help but cost $10-25/GB, and Amazon's anti-bot measures have gotten significantly more sophisticated in 2026.

Even when scraping works, the extracted data is often incomplete. Amazon shows different products to different users based on location, browsing history, and account status. A scraper running from a datacenter IP sees different results than what a logged-in seller sees in their browser.

The API Approach

A search API that covers Amazon returns structured product data including ASINs, titles, prices, ratings, and review counts. You query category keywords and extract the ASINs from the results. No proxy management, no DOM parsing, no anti-bot evasion.

import os
import json
import time
import requests

API = "https://api.scavio.dev"
H = {"Authorization": f"Bearer {os.environ['SCAVIO_API_KEY']}"}

def get_asins_for_category(category_keyword, pages=1):
    """Get ASINs for a product category from Amazon search results."""
    asins = []
    for page in range(1, pages + 1):
        response = requests.post(
            f"{API}/api/v1/amazon/search",
            headers=H,
            json={"query": category_keyword, "country": "us", "page": page},
            timeout=90,
        )
        response.raise_for_status()
        data = response.json()["data"]

        for product in data.get("products", []):
            asins.append({
                "asin": product["asin"],
                "title": product.get("title", ""),
                "url": f"https://www.amazon.com/dp/{product['asin']}",
                "price": product.get("price"),
                "rating": product.get("rating"),
                "reviews_count": product.get("reviews_count"),
            })
    return asins

Each product already carries its asin, so there is no URL parsing step. products also returns price, rating, reviews_count, is_sponsored and sales_volume ("1K+ bought in past month") for every result, which the filtering step below can use directly.

Bulk Category Scanning

To replicate the 1,449 ASIN check from the Reddit post, you need to scan multiple category keywords. Here is a pipeline that scans a list of categories and builds a deduplicated ASIN database:

def bulk_scan_categories(categories, pages_per_category=1):
    """Scan multiple categories and build ASIN database."""
    all_asins = {}

    for category in categories:
        print(f"Scanning: {category}")
        results = get_asins_for_category(category, pages_per_category)

        for item in results:
            asin = item["asin"]
            if asin not in all_asins:
                all_asins[asin] = {
                    "asin": asin,
                    "title": item["title"],
                    "url": item["url"],
                    "reviews_count": item["reviews_count"],
                    "categories": [category],
                }
            else:
                all_asins[asin]["categories"].append(category)

        time.sleep(0.3)  # Rate limiting

    print(f"Found {len(all_asins)} unique ASINs")
    return list(all_asins.values())

# Example: scanning toy categories
categories = [
    "best selling toys 2026",
    "educational toys for kids",
    "building blocks sets",
    "remote control cars for kids",
    "board games family",
    "outdoor toys backyard",
    "stem toys for children",
    "arts and crafts kits kids",
]

asins = bulk_scan_categories(categories)

# Save for batch eligibility checking
with open("asin_candidates.json", "w") as f:
    json.dump(asins, f, indent=2)

print(f"Saved {len(asins)} ASINs for eligibility check")

Cost Analysis

The Reddit post described checking 1,449 ASINs. To collect that many ASINs via search API:

• At roughly 20 products per results page, you need approximately 75-100 queries (accounting for duplicates across categories).
• At 1 credit per query, that is 75-100 credits: $0.75-$1.00 on pay-as-you-go, or about $0.20 at the Growth plan's yearly rate.
• The search takes under 2 minutes with rate limiting.

Compare this to 12 hours of manual browsing or $30-50 in proxy costs for a scraping approach that may or may not succeed.

Enriching ASIN Data

Raw ASINs are a starting point. Before checking eligibility, you want to filter by profitability signals. A second pass of searches can enrich each ASIN with competitive data:

def enrich_asin(asin):
    """Get competitive data for a specific ASIN."""
    response = requests.post(
        f"{API}/api/v1/amazon/product",
        headers=H,
        json={"asin": asin, "country": "us"},
        timeout=90,
    )
    response.raise_for_status()
    product = response.json()["data"]

    return {
        "asin": asin,
        "title": product.get("title", ""),
        "price": product.get("price"),
        "rating": product.get("rating"),
        "reviews_count": product.get("reviews_count"),
        "has_multiple_sellers": (product.get("other_sellers_count") or 0) > 0,
        "sold_by": product.get("sold_by"),
        "best_sellers_rank": product.get("best_sellers_rank", []),
    }

def filter_candidates(asins, min_reviews=50, max_reviews=5000):
    """Filter ASINs based on basic profitability signals."""
    candidates = []
    for item in asins:
        # Products with very few reviews might be too new or niche
        # Products with too many might be too competitive
        reviews = item.get("reviews_count") or 0
        if min_reviews <= reviews <= max_reviews:
            candidates.append(item)
    return candidates

The product call is also 1 credit and returns the buy-box seller (sold_by), other_sellers_count and best_sellers_rank per category. If you need every competing offer rather than a count, /api/v1/amazon/offers lists each seller with price, condition, FBA status and which one holds the buy box.

The Eligibility Check Workflow

After collecting and filtering ASINs, the eligibility check itself still requires Seller Central. Amazon does not expose eligibility data through any public API. The workflow is:

• Step 1: Collect ASINs via search API (automated, 2 minutes)
• Step 2: Filter by profitability signals (automated, 1 minute)
• Step 3: Export filtered list to CSV
• Step 4: Batch check in Seller Central using add product flow

Some sellers use tools like Keepa or Helium 10 for the eligibility check step, which can process ASIN lists in bulk. The search API handles the discovery step where you go from "I want to sell toys" to a list of 1,000+ specific ASINs to evaluate.

Monitoring Category Changes

Product categories shift. New products enter, old ones go out of stock, pricing changes weekly. Setting up a recurring scan catches new opportunities:

def detect_new_asins(categories, known_asins_file):
    """Find newly appeared ASINs in target categories."""
    # Load previously known ASINs
    with open(known_asins_file) as f:
        known = set(json.load(f))

    current = bulk_scan_categories(categories)
    current_asins = {item["asin"] for item in current}

    new_asins = current_asins - known
    removed_asins = known - current_asins

    print(f"New ASINs: {len(new_asins)}")
    print(f"Removed ASINs: {len(removed_asins)}")

    # Save updated known set
    with open(known_asins_file, "w") as f:
        json.dump(list(current_asins), f)

    return [item for item in current if item["asin"] in new_asins]

Running this weekly costs $2-4/month depending on category count and gives you a continuous pipeline of new ASIN candidates to evaluate.

Limitations

Search API results do not cover every product in a category. Amazon has millions of products per category; a search query returns one results page at a time, and you pay per page. This is fine for finding competitive, high-visibility products but will miss long-tail items with low search visibility.

For exhaustive category coverage, you would need Amazon's Product Advertising API (PA-API), which requires an Associates account and has its own rate limits (1 request/second). The search API approach is better for rapid discovery and filtering; PA-API is better for comprehensive catalog coverage.