# DigiKey Parts Scraper (`fetchfinch/digikey-parts-scraper`) Actor

\[ 💰 $1.50 / 1K] Search DigiKey by keyword, part number, BOM, or product URL. Get structured records with stock, lead times, quantity pricing, specs, compliance, lifecycle, origin, datasheets, images, and product links. From $1.50 per 1,000 records, plus a $0.10 start event.

- **URL**: https://apify.com/fetchfinch/digikey-parts-scraper.md
- **Developed by:** [Fetch Finch](https://apify.com/fetchfinch) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 record scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### DigiKey Parts Scraper

![No external API key required](https://img.shields.io/badge/Setup-no%20external%20API%20key-43A047)
![Pricing](https://img.shields.io/badge/Pricing-pay%20per%20result-5C6BC0)
![Workflows](https://img.shields.io/badge/Workflows-4%20ways%20to%20search-00A98F)
![Output](https://img.shields.io/badge/Output-structured%20JSON-3178C6)
![Catalog](https://img.shields.io/badge/Catalog-DigiKey-F39C12)

Collect structured product data from DigiKey for component research, sourcing, price comparisons, and BOM enrichment. Search by keyword or part number, browse a category, resolve a bill of materials, or provide product URLs. Results are saved to the Apify dataset for filtering, automation, and export.

No DigiKey API key or separate data-provider account is needed. Choose a workflow, enter your search or product identifiers, and run the Actor.

### What you can do

| Workflow | Use it to | Main input |
| --- | --- | --- |
| Search | Find products by keyword, manufacturer part number, or DigiKey part number | `query` |
| Category browse | Collect products from a DigiKey category and its result pages | `categoryUrl` |
| BOM lookup | Resolve a list of manufacturer or DigiKey part numbers to product records | `partNumbers` |
| Product URLs | Enrich known DigiKey product pages directly | `productUrls` |

### Product data

Each result is a structured product record. Fields are included when DigiKey provides them for the selected product and locale.

| Data group | Fields |
| --- | --- |
| Identifiers | DigiKey part number, manufacturer part number, manufacturer, product URL |
| Product details | Product name, short and full descriptions, category, subcategory, family, series, packaging |
| Availability | Stock quantity and status, standard lead time, minimum order quantity, non-stock status |
| Pricing | Currency and quantity price breaks |
| Compliance and lifecycle | RoHS, REACH, moisture sensitivity, lifecycle status, country of origin, tariff code |
| Technical resources | Parametric attributes, datasheet URL, product image URL |

Price and stock information is a snapshot from the product page when it is scraped. Values can change, and availability or fields may vary by product and locale; confirm purchasing decisions with DigiKey.

### Pricing

The Actor charges for each successfully scraped product record. The per-record rates below are shown per 1,000 records:

| Apify plan tier | Record events per 1,000 records | Total for 1,000 records in one default-memory run |
| --- | ---: | ---: |
| Free | $1.90 | $2.00 |
| Starter | $1.90 | $2.00 |
| Scale | $1.70 | $1.80 |
| Business | $1.50 | $1.60 |
| Platinum / Diamond | $1.50 | $1.60 |

The total column includes the **$0.10 Actor Start event per run**. At the default 512 MB memory allocation, one start event is charged per run; Apify may apply additional start events when a run uses more than 1 GB of memory. These are introductory rates and may be revised. Failed lookups and products filtered out before a result is emitted are not charged as product records.

### Quick start

Select a mode and provide the matching input. The remaining examples can be pasted into the Apify input editor and adjusted as needed.

#### Search

```json
{
  "mode": "search",
  "query": "STM32F103C8T6",
  "maxItems": 10,
  "extractParametrics": true
}
```

#### BOM lookup

```json
{
  "mode": "bom",
  "partNumbers": [
    "RC0402FR-07100KL",
    "GRM155R61A105KE15D",
    "STM32F103C8T6"
  ],
  "maxItems": 3
}
```

#### Category browse

```json
{
  "mode": "category",
  "categoryUrl": "https://www.digikey.com/en/products/filter/resistors/52",
  "inStockOnly": true,
  "maxItems": 100
}
```

#### Product URLs

```json
{
  "mode": "urls",
  "productUrls": [
    "https://www.digikey.com/en/products/detail/stmicroelectronics/STM32F103C8T6/1646338"
  ],
  "maxItems": 1
}
```

### Input options

| Option | Applies to | Description |
| --- | --- | --- |
| `mode` | All | `search`, `category`, `bom`, or `urls`. |
| `query` | Search | Keyword, manufacturer part number, or DigiKey part number. |
| `categoryUrl` | Category | A DigiKey category/filter URL. |
| `partNumbers` | BOM | List of manufacturer or DigiKey part numbers. |
| `productUrls` | URLs | List of DigiKey product-detail URLs. |
| `maxItems` | All | Maximum number of records to return (1–10,000). |
| `manufacturer` | All | Optional case-insensitive manufacturer filter. |
| `inStockOnly` | All | Return only products with a positive available quantity. |
| `extractParametrics` | All | Include the product's technical attributes (enabled by default). |
| `maxConcurrency` | All | Number of product detail requests to process concurrently. |
| `requestDelaySecs` | All | Minimum delay between requests per worker. |

### Results and export

Records are written to the run's default Apify dataset. You can inspect them in the Console, retrieve them with the Apify API, or export the dataset in formats supported by Apify, including JSON and CSV.

`price_breaks` is an array of `{ "qty", "price" }` objects. `parametric_attributes` is a JSON object when available and enabled, or `null`. When a DigiKey page offers multiple packaging variants, the output represents the page's selected/default offer.

### Common use cases

- Compare availability and quantity pricing across a component shortlist.
- Enrich a BOM with DigiKey links, stock, lead times, compliance, and technical details.
- Build a structured catalog from a DigiKey category.
- Refresh product metadata for an existing set of DigiKey product URLs.
- Feed component data into inventory, sourcing, or analytics workflows.

### Notes

- Results reflect the DigiKey page and locale accessed during the run; prices, availability, and compliance data can change.
- Product attributes and supporting links vary by product.
- Use the data in accordance with DigiKey's terms and applicable laws.

# Actor input Schema

## `mode` (type: `string`):

How to find DigiKey products.

## `categoryUrl` (type: `string`):

A digikey.com /en/products/filter/... URL. Used in category mode.

## `query` (type: `string`):

Keyword, manufacturer part number, or DigiKey part number. Used in search mode.

## `partNumbers` (type: `array`):

One manufacturer or DigiKey part number per item. Used in BOM mode.

## `productUrls` (type: `array`):

DigiKey product-detail URLs to scrape directly. Used in Product URLs mode.

## `manufacturer` (type: `string`):

Optional case-insensitive manufacturer filter applied to extracted records.

## `inStockOnly` (type: `boolean`):

Discard products whose current available quantity is zero or unavailable.

## `extractParametrics` (type: `boolean`):

Include the complete Product Attributes table.

## `maxItems` (type: `integer`):

Maximum number of dataset records.

## `maxConcurrency` (type: `integer`):

Concurrent detail requests. Keep this low to reduce blocking.

## `requestDelaySecs` (type: `number`):

Minimum delay per worker, in seconds.

## `customProxyAttempts` (type: `integer`):

Attempts made through RESIDENTIAL\_PROXY\_URL before switching to Apify Proxy. Rotating pools may need several exits to find one DigiKey accepts.

## `saveDebugHtml` (type: `boolean`):

Save successful product responses to the run's key-value store for parser troubleshooting. Disabled by default.

## `brightDataAttempts` (type: `integer`):

Attempts through Bright Data Web Unlocker before using RESIDENTIAL\_PROXY\_URL and then Apify Proxy. Only used when BRIGHTDATA\_API\_KEY and BRIGHTDATA\_ZONE are configured as Actor environment variables.

## `proxyConfiguration` (type: `object`):

Fallback proxy settings. Bright Data Web Unlocker is configured at the Actor level, so callers normally do not need to change this.

## Actor input object example

```json
{
  "mode": "search",
  "query": "STM32F103C8T6",
  "partNumbers": [
    "RC0402FR-07100KL",
    "STM32F103C8T6"
  ],
  "inStockOnly": false,
  "extractParametrics": true,
  "maxItems": 100,
  "maxConcurrency": 3,
  "requestDelaySecs": 1.5,
  "customProxyAttempts": 8,
  "saveDebugHtml": false,
  "brightDataAttempts": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchfinch/digikey-parts-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("fetchfinch/digikey-parts-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call fetchfinch/digikey-parts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetchfinch/digikey-parts-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ug2uj0dOA7ZeVQO1i/builds/ybh1PpuMTEISfe9Nd/openapi.json