For a production-scale ASIN workflow, use Amazon’s authorized API rather than scraping product-page HTML: use SearchItems to discover products and GetItems to retrieve records in batches of up to 10 ASINs. Normalize and deduplicate identifiers, request only the fields you need, and build in throttling, retries, checkpoints, and explicit handling for inaccessible IDs. Amazon’s indexed Product Advertising API documentation gives May 15, 2026 as the PA-API deprecation date; that date has passed, so verify current Creators API access, authentication, quotas, and field support before choosing an API integration.
Choose an acquisition method before collecting data
“Scraping ASIN data” can mean two different jobs: discovering product identifiers and collecting product attributes for known identifiers. Amazon’s documented API operations fit those jobs directly: SearchItems discovers items from a query, while GetItems retrieves data for ASINs you already have. For recurring or large collections, use the authorized API route and confirm the current program terms and marketplace requirements.
HTML scraping is a separate option, not a shortcut around API access controls. Page markup can change, automated requests may be throttled or blocked, and permission to crawl is not permission to collect, store, or republish the resulting information. Amazon’s Product Discovery Bot documentation says that bot respects robots.txt; that statement does not itself grant third parties permission to scrape Amazon pages.
Before implementation, define the marketplace, intended use, required fields, refresh cadence, and retention policy. API resources vary by locale, and product prices or availability should not be presented as current unless you store when they were retrieved.
#1 Best Overall
Account for the PA-API deprecation date
Amazon Product Advertising API documentation indexed in 2026 states: “PA-API will be deprecated on May 15th, 2026. Please migrate to Creators API.” May 15, 2026 is now in the past. The available information establishes the announced date, but not the current operating status or present-day Creators API requirements. Treat migration as a release dependency: verify access, quotas, authentication, supported resources, and data-retention rules against Amazon’s current documentation before building or shipping.
Do not assume an older PA-API code sample or third-party Python wrapper remains suitable. Pin wrapper versions, inspect the requests they generate, and keep the data-processing layer independent from the API transport so an API change does not force a rewrite of your storage and downstream jobs.
Build the pipeline around ASINs
1. Define marketplace and fields
Choose one marketplace explicitly for each discovery and retrieval job. Decide whether you need only identifiers and titles or also fields such as brand, images, offers, browse nodes, or parent ASIN. Requesting only relevant resources reduces response size and avoids depending on fields your use case does not need.
2. Discover and persist identifiers
Use SearchItems with the appropriate keywords, search index, and marketplace settings for product discovery. Persist returned ASINs and parent relationships instead of treating a one-time search result as a durable source of truth. Search results are a discovery mechanism, not a guarantee that every desired item will remain retrievable.
3. Fetch in batches and inspect both result containers
Amazon’s Product Advertising API documentation indexed in 2026 specifies a maximum of 10 ASINs per GetItems request. Split larger input sets into groups of 10 or fewer. Examine both Items and Errors in each response: an inaccessible ID may be reported separately from successfully returned records. Store those outcomes separately; do not silently discard errors or label every requested ASIN as a successful product record.
4. Normalize, deduplicate, and checkpoint
Normalize ASINs to uppercase before deduplication. Record the marketplace and retrieval time with each result, and retain raw responses for audit only where applicable policy permits. Save progress after each completed batch so a timeout or throttling event does not require restarting the entire collection. Keep credentials out of source control and redact them from logs.
Python: validate ASINs, batch them, and checkpoint results
The following standard-library script is a runnable foundation for a retrieval pipeline. It reads one ASIN per line, validates the 10-character alphanumeric format, removes duplicates, groups valid IDs into batches of at most 10, and writes a checkpoint record for every batch. It deliberately does not invent a live Amazon endpoint or signing configuration: wire fetch_batch to the currently supported, authenticated Creators API client after confirming its current request format. The API adapter must preserve separate success and error records returned by the service.
import json
import re
import sys
import time
from pathlib import Path
ASIN_RE = re.compile(r"^[A-Z0-9]{10}$")
BATCH_SIZE = 10
INPUT = Path(sys.argv[1] if len(sys.argv) > 1 else "asins.txt")
CHECKPOINT = Path("asin_checkpoint.jsonl")
def load_asins(path):
seen = set()
valid, invalid = [], []
for line_number, raw in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
value = raw.strip().upper()
if not value:
continue
if not ASIN_RE.fullmatch(value):
invalid.append({"line": line_number, "value": raw, "reason": "not 10 alphanumeric characters"})
elif value not in seen:
seen.add(value)
valid.append(value)
return valid, invalid
def batches(values, size=BATCH_SIZE):
for start in range(0, len(values), size):
yield values[start:start + size]
def fetch_batch(asins, marketplace):
"""Replace with the currently documented, authenticated API client call.
Return a JSON-serializable object that retains the API's successful Items
and its Errors separately. Confirm Creators API details before use.
"""
raise NotImplementedError("Connect a verified Creators API adapter")
def main():
if not INPUT.exists():
raise SystemExit(f"Input file not found: {INPUT}")
asins, invalid = load_asins(INPUT)
marketplace = "SET_MARKETPLACE_EXPLICITLY"
if marketplace.startswith("SET_"):
raise SystemExit("Set marketplace to the marketplace configured in your verified API adapter")
with CHECKPOINT.open("a", encoding="utf-8") as output:
for row in invalid:
output.write(json.dumps({"type": "invalid_input", **row}) + "n")
for number, group in enumerate(batches(asins), 1):
try:
result = fetch_batch(group, marketplace)
output.write(json.dumps({
"type": "batch_result", "batch": number,
"marketplace": marketplace, "requested_asins": group,
"retrieved_at_epoch": int(time.time()), "response": result
}, ensure_ascii=False) + "n")
output.flush()
except Exception as exc:
output.write(json.dumps({
"type": "batch_failure", "batch": number,
"marketplace": marketplace, "requested_asins": group,
"error": str(exc)
}, ensure_ascii=False) + "n")
output.flush()
raise
print(f"Prepared {len(asins)} unique ASINs; checkpoint: {CHECKPOINT}")
if __name__ == "__main__":
main()Run it with python collect_asins.py input_asins.txt after setting a real marketplace and replacing the adapter. The initial run exits until those integration-specific values are supplied. This separation is intentional: Amazon’s indexed material establishes the operations and batch limit, but the supplied facts do not establish a current Creators API endpoint, Python SDK, request schema, or signing recipe. Do not copy a PA-API signer into production without checking the current specification.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Signing, throttling, retries, and request efficiency
Authenticate against the current API specification
The documented PA-API transport uses AWS Signature Version 4 and required request headers; affiliate API access also requires partner parameters. The signing inputs must match the configured marketplace host, region, timestamp, and request body. Since the deprecation date has passed and current Creators API requirements are not established here, obtain those exact details from Amazon’s current documentation rather than guessing at header names, endpoints, or signature scope. Never print authorization headers, access keys, or secret keys in exception logs.
Respect account-specific limits
Amazon Associates Central’s current help page, indexed in 2026, lists an initial rate of 1 request per second, an increase of 1 request per second per $4,600 in shipped revenue, and a cap of 10 requests per second. These are account-dependent limits, not a safe universal rate for every integration or future API. Configure a token bucket or equivalent limiter below the quota Amazon confirms for your account. Use bounded concurrency; unbounded parallel requests can turn an otherwise valid job into a throttling loop.
Retry transient failures without duplicating work
For throttling and temporary network failures, use exponential backoff with jitter and a finite retry limit. Do not repeatedly retry validation errors, authorization failures, unsupported resources, or permanently inaccessible IDs as though they were transient. Record the failed batch and response category, then resume from checkpoints. If the API provides a distinct error container, route those item-level errors into a reviewable failure record rather than retrying the entire batch blindly.
Minimize payload and make pagination explicit
Request only resources needed for the job, such as ItemInfo, Images, BrowseNodeInfo, Offers/OffersV2, or ParentASIN, subject to current marketplace and API support. For discovery, handle pagination using the current API’s documented continuation mechanism. Persist pagination state alongside the search job so interruptions do not lose the ability to continue or create accidental repeated work.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11API retrieval versus scraping HTML
| Consideration | Authorized API workflow | HTML scraping |
|---|---|---|
| Permission and terms | Use only with the required program access and according to applicable API terms. | Requires marketplace-specific compliance review; robots.txt behavior does not grant collection or reuse permission. |
| Fields and format | Structured operations and resources such as item information or images, subject to locale and current API support. | Depends on page markup, which can change; fields may be absent or rendered dynamically. |
| Scale controls | Account-dependent quotas and documented batch retrieval; build a limiter and backoff. | Automated requests can be blocked or throttled; scraping does not establish an authorized throughput. |
| Failure handling | Inspect returned items and errors, checkpoint work, and separate inaccessible ASINs. | Must detect blocks, incomplete pages, markup changes, and missing content in your own parser. |
| Long-term risk | PA-API deprecation date has passed; verify Creators API migration requirements before release. | Page and policy changes can invalidate parsers, and compliance obligations remain separate from crawler behavior. |
Store data so it remains useful and auditable
- Use a composite record key. Store marketplace plus uppercase ASIN; an identifier collected for one marketplace should not silently stand in for another locale’s record.
- Keep observation time. Store retrieval timestamps for changing fields such as offers or availability, and avoid describing an old observation as current.
- Separate statuses. Distinguish valid input, successfully retrieved item, inaccessible or errored item, and transient batch failure.
- Retain provenance carefully. Preserve raw API responses only if the applicable program policy permits it; enforce retention limits and restrict access.
- Make jobs restartable. Checkpoint batches and search pagination state, and make downstream writes idempotent so replaying a completed batch does not create duplicate products.
Troubleshooting common failures
- Signature or authorization rejection: confirm credentials and program eligibility, then verify the exact current signing requirements, marketplace host, region, timestamp, and body. Do not assume PA-API signing instructions apply unchanged to Creators API.
- Throttling: reduce request rate and concurrency, honor any retry guidance, and use bounded exponential backoff. Check the quota attached to the account rather than treating the published initial rate as guaranteed for your account.
- Some ASINs are missing: inspect the response’s
Errorscontainer and record affected IDs separately. Verify marketplace, input normalization, and resource availability before retrying. - Unexpectedly large or slow responses: remove unneeded resources and fetch at most 10 ASINs per
GetItemsrequest. - Duplicate rows after restart: use an idempotent storage key based on marketplace and normalized ASIN; resume from durable checkpoints instead of appending unconditionally.
- Scraper returns a challenge, blank page, or changed layout: stop treating the response as product data. Reassess permission and use an authorized API workflow instead of trying to evade bot protections.
Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server, not an Amazon catalog API: it returns a screenshot or PDF of a page, not structured ASIN fields. Use it when the separate job is to capture a visual record of a product page, not to discover or retrieve catalog data. Its one-call screenshot example is:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request options. ScreenshotNeo accepts cookie or consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers identify the page verdict and billing status. It also offers an MCP server for AI agents, with take_screenshot, get_page_info, and capture_pdf. The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000.
Sign up for ScreenshotNeo’s free plan to try visual page capture; use Amazon’s authorized API for structured ASIN collection.
Frequently asked questions
Is an ASIN the same as a product URL?
No. An ASIN is Amazon’s 10-character alphanumeric item identifier; a product URL is an address that may contain or resolve to an identifier.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Should I store parent ASINs?
If parent-child product relationships matter to your application, capture and store the parent relationship when the marketplace and current API response support it.
Can a Python wrapper replace direct API knowledge?
A wrapper can reduce boilerplate, but it cannot remove the need to verify current API access, signing, supported fields, quotas, retries, and license terms. Pin its version and inspect generated requests.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
