Analog APIanalog.com ↗
Access Analog Devices part specs, pricing, lifecycle status, and category data via 8 endpoints. Search parts, fetch parametric specs, and retrieve buy models.
What is the Analog API?
The Analog Devices API covers 8 endpoints that expose the full analog.com product catalog — from top-level categories down to individual part specifications, pricing tiers, and purchase options. With endpoints like get_part_specifications and get_part_sample_buy, you can pull parametric spec tables, lifecycle status, package types, lead times, and multi-tier pricing for any part number in the ADI portfolio.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/9cd5ab9e-1120-4fa1-8904-cd82a5492fb0/get_product_categories' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace analog-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Analog Devices SDK — browse catalog, search parts, drill into details."""
from parse_apis.Analog_Devices_API import AnalogDevices, PartNotFound
adi = AnalogDevices()
# Browse top-level product categories
for category in adi.categories.list(limit=5):
print(category.name, category.slug, category.pst_id)
# Drill into subcategories of a specific category
amplifiers = adi.category("amplifiers")
for subcat in amplifiers.subcategories.list(limit=3):
print(subcat.name, subcat.slug, subcat.pst_id)
# Search for parts by keyword
result = adi.parts.search(query="temperature sensor", limit=1).first()
if result:
print(result.title, result.part_number, result.url)
# Fetch a specific part by part number
part = adi.parts.get(part_number="AD7124-8")
print(part.title, part.lifecycle, part.starting_price)
# Access features via instance method
features = part.get_features()
for feat in features.features[:3]:
print(feat)
# Access details (description + applications)
details = part.get_details()
print(details.description)
for app in details.applications:
print(app)
# Access parametric specifications via sub-resource
for spec in part.specifications.list(limit=1):
print(spec.part_number, spec.specs)
# Access pricing and buy options
buy = part.get_buy_options()
print(buy.product_life_cycle_status, buy.generic)
for model in buy.buy_models[:2]:
print(model.model, model.package, model.life_cycle, model.lead_time)
# Typed error handling for a non-existent part
try:
adi.parts.get(part_number="NONEXISTENT999")
except PartNotFound as exc:
print(f"Part not found: {exc.part_number}")
print("exercised: categories.list / subcategories.list / parts.search / parts.get / get_features / get_details / specifications.list / get_buy_options")
Returns all top-level product categories from the Analog Devices catalog. Each category includes a name, slug, URL, and optional parametric search table ID (pst_id). Categories without a pst_id require drilling into subcategories to find one.
No input parameters required.
{
"type": "object",
"fields": {
"items": "array of category objects each containing name, slug, url, and pst_id (nullable)"
},
"sample": {
"data": {
"items": [
{
"url": "https://www.analog.com/en/product-category/amplifiers.html",
"name": "Amplifiers",
"slug": "amplifiers",
"pst_id": null
},
{
"url": "https://www.analog.com/en/product-category/voltage-references.html",
"name": "Voltage References",
"slug": "voltage-references",
"pst_id": "2472"
}
]
},
"status": "success"
}
}About the Analog API
Category and Part Discovery
get_product_categories returns all top-level categories with name, slug, url, and pst_id (parametric search table ID). Pass any category_slug from those results into get_subcategories to walk the full category tree. Both endpoints return the pst_id field, which is the key input for get_part_specifications when you want all parts in a given category rather than a single part number.
Part Data Endpoints
Three endpoints cover different layers of a part's product page. get_part_overview returns part_number, title, lifecycle, short_description, models_count, and starting_price — useful for quick screening. get_part_features returns a flat array of feature strings as listed on the product page. get_part_details returns a longer description string and an applications array naming the target use cases for the part.
Specifications and Pricing
get_part_specifications accepts either a pst_id (for category-wide results) or a part_number (which auto-detects the pst_id and filters to that single part). The response is an array of objects each containing part_number, url, and a specs object whose keys are specification names and values are the corresponding values. Note that very large categories may fail to parse due to data volume — prefer subcategory pst_id values or individual part lookups when possible. get_part_sample_buy returns the buyModels array with per-model pricing tiers, package types, lead times, and productLifeCycleStatus.
Search
search_parts takes a query string and optional page (0-based) and limit parameters. Results include products, documentation, tools, and other resources — each with part_number (nullable), title, description, url, and a category object (nullable). This makes it useful for broad keyword searches like 'op amp' as well as targeted part number lookups.
The Analog API is a managed, monitored endpoint for analog.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when analog.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official analog.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a parametric part selector by pulling specs from
get_part_specificationsfor a subcategory pst_id and filtering on key parameters - Track lifecycle status changes across a BOM by periodically calling
get_part_overviewfor each part number - Retrieve multi-tier pricing and lead times from
get_part_sample_buyto feed procurement or cost-estimation tools - Walk the category tree with
get_product_categoriesandget_subcategoriesto build a local mirror of the ADI product taxonomy - Use
search_partsto resolve user-typed part number fragments or keywords against the live ADI catalog - Extract application markets from
get_part_detailsto tag parts with target end-market metadata
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Analog Devices offer an official developer API?+
What does `get_part_specifications` return and when should I use `pst_id` versus `part_number`?+
part_number, url, and a specs key containing name-value pairs for all parametric specifications. Use pst_id (obtained from category or subcategory endpoints) to retrieve all parts in a category at once. Use part_number when you want specs for a single part without looking up its pst_id manually — the endpoint detects it automatically and filters the results. Avoid using category-level pst_ids for very large categories, as the response may exceed parse limits.What does `get_part_sample_buy` return beyond just price?+
buyModels array, which includes individual model variants with pricing tiers (quantity breaks), package types, lead times, and per-model productLifeCycleStatus. It also returns a generic part number and label metadata. This covers the same buy-model data shown on the product page's pricing section.Does the API return datasheet PDFs or other documentation file links?+
search_parts surfaces. You can fork the API on Parse and revise it to add an endpoint targeting datasheet and reference design document links.Does `search_parts` return only products, or other content types too?+
part_number field populated), as well as documentation, tools, and other resources where part_number is null. The category field is also nullable and will be absent for non-product results. If you need only product results, filter client-side on records where part_number is non-null.