# LCSC Parts Scraper — Prices, Stock, Specs & Datasheets (`minty_modesty/lcsc-parts-scraper`) Actor

Turn a list of LCSC part codes (C-numbers) into clean JSON: full quantity price ladder, live stock, parametric specs, package, MOQ and datasheet URL. Ideal for BOM costing and JLCPCB assembly.

- **URL**: https://apify.com/minty\_modesty/lcsc-parts-scraper.md
- **Developed by:** [Minty Modesty](https://apify.com/minty_modesty) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## LCSC Parts Scraper — Prices, Stock, Specs & Datasheets

Turn a list of **LCSC part codes** (the `C#####` numbers on every LCSC product page and in every JLCPCB / LCSC BOM) into **clean, structured JSON**: the full quantity price ladder, live stock, parametric specifications, package, minimum order quantity and the manufacturer datasheet URL.

Built for **BOM costing, JLCPCB assembly quoting, price monitoring, and component database enrichment**. Give it your part numbers, get back a spreadsheet-ready dataset.

> Why this actor exists: distributors like Digi-Key and Mouser have scrapers on Apify — **LCSC did not**. LCSC is the low-cost distributor that hardware teams and JLCPCB users buy from every day, so its live prices and stock are exactly what you need to cost a build. This actor fills that gap.

***

### What it does

- **Input:** a list of LCSC part codes (`C1591`, `C25804`, …) and/or LCSC `product-detail` URLs.
- **Output:** one clean record per part — identity, category, live stock, package, MOQ, **full price ladder**, **parametric specs**, and **datasheet URL**.
- **Reliable by design:** reads only public LCSC product pages (allowed by LCSC's `robots.txt`), one lightweight request per part. No login, no search-API reverse-engineering, no CAPTCHA farms — so it keeps working.

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `productCodes` | array of strings | – | LCSC part codes, e.g. `["C1591", "C25804"]`. With or without the leading `C`. This is the main input. |
| `productUrls` | array of strings | – | Optional. Full LCSC `product-detail` URLs. Use instead of or alongside codes. |
| `maxItems` | integer | `0` | Cap on parts to scrape. `0` = no limit. |
| `includePriceTiers` | boolean | `true` | Include the full quantity-break price ladder. |
| `includeSpecs` | boolean | `true` | Include parametric attributes (resistance, capacitance, voltage, tolerance, …). |
| `includeDatasheet` | boolean | `true` | Include the manufacturer datasheet PDF URL. |
| `includeImages` | boolean | `false` | Include product image URLs. |
| `maxConcurrency` | integer | `5` | Parallel requests. Keep low to stay polite to LCSC. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings. Default datacenter proxy is usually enough. |

#### Example input

```json
{
  "productCodes": ["C1591", "C25804", "C7593"],
  "includePriceTiers": true,
  "includeSpecs": true,
  "maxConcurrency": 5
}
```

### Output

One dataset record per part. Real output for `C1591` (a Samsung 100 nF 0603 capacitor), captured live:

```json
{
  "productCode": "C1591",
  "mpn": "CL10B104KB8NNNC",
  "brand": "Samsung Electro-Mechanics",
  "description": "CAP CER 100nF 50V X7R 0603",
  "categoryPath": "Capacitors > Ceramic Capacitors",
  "category": "Ceramic Capacitors",
  "parentCategory": "Capacitors",
  "stock": 2756000,
  "package": "0603",
  "packaging": "Tape & Reel (TR)",
  "minOrderQty": 100,
  "orderMultiple": 100,
  "unit": "Piece",
  "rohs": true,
  "weightGrams": 0.041,
  "currency": "USD",
  "url": "https://www.lcsc.com/product-detail/C1591.html",
  "priceTiers": [
    { "quantity": 100,    "unitPrice": 0.0195, "currency": "USD" },
    { "quantity": 1000,   "unitPrice": 0.0163, "currency": "USD" },
    { "quantity": 4000,   "unitPrice": 0.0148, "currency": "USD" },
    { "quantity": 8000,   "unitPrice": 0.0138, "currency": "USD" },
    { "quantity": 48000,  "unitPrice": 0.0133, "currency": "USD" },
    { "quantity": 100000, "unitPrice": 0.0130, "currency": "USD" }
  ],
  "specs": {
    "Capacitance": "100nF",
    "Temperature Coefficient": "X7R",
    "Tolerance": "±10%",
    "Voltage Rating": "50V"
  },
  "datasheetUrl": "https://datasheet.lcsc.com/datasheet/pdf/02336ea48ea44ca18c72517dd3cb7b47.pdf?productCode=C1591",
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

#### Output field reference

| Field | Description |
|---|---|
| `productCode` | LCSC part number (the `C#####`). |
| `mpn` | Manufacturer part number. |
| `brand` | Manufacturer / brand. |
| `description` | Short English product description. |
| `categoryPath` / `category` / `parentCategory` | LCSC category, e.g. `Capacitors > Ceramic Capacitors`. |
| `stock` | Live stock quantity. |
| `package` | Package / footprint, e.g. `0603`, `SOP-8`. |
| `packaging` | Supply form, e.g. `Tape & Reel (TR)`. |
| `minOrderQty` | Minimum order quantity. |
| `orderMultiple` | Order increment (must order in multiples of this). |
| `unit` | Selling unit, e.g. `Piece`. |
| `rohs` | RoHS / environmental flag. |
| `weightGrams` | Unit weight in grams. |
| `priceTiers[]` | Quantity price ladder: `{ quantity, unitPrice, currency }`. Prices are USD. |
| `specs` | Parametric attributes as a `name → value` object. Keys vary by component type. |
| `datasheetUrl` | Manufacturer datasheet PDF. |
| `url` | Canonical LCSC product-detail URL. |
| `scrapedAt` | ISO timestamp of capture. |

Codes that do not resolve to a product are returned as `{ "productCode": "C000...", "error": "not_found" }` so your run never silently drops a line item.

### Typical use cases

- **BOM costing:** paste every `C#####` from a JLCPCB/LCSC BOM and get the exact unit price at your build quantity, plus a stock check — in one run.
- **Price & stock monitoring:** schedule the actor daily on a watchlist of critical parts and diff the price ladder / stock over time.
- **Component database enrichment:** hydrate your internal parts library or PLM with specs, package, datasheet and pricing.
- **Sourcing / cost-down analysis:** compare LCSC pricing against other distributors you already scrape.

### How to get part codes

You almost always already have them:

- Your **JLCPCB assembly BOM** lists the `LCSC Part #` column (`C#####`).
- Every LCSC product page shows the code as **"LCSC Part #"**.
- Your LCSC cart / order history lists them.

Paste those codes into `productCodes` and run.

### Limitations (read before buying)

- **Discovery is by part code, not keyword search.** This is deliberate: it keeps the actor on stable public product pages and avoids LCSC's protected search endpoints, so it stays reliable and does not get blocked. If you need keyword → codes, resolve codes first (from your BOM or on lcsc.com) and feed them here.
- **Prices are the USD list prices** shown on the international LCSC site. They exclude shipping, taxes and any account-specific discounts.
- **Specs keys vary by component family** (a resistor exposes `Resistance`; a capacitor exposes `Capacitance`). `specs` is a flexible object, not a fixed schema.
- **Stock and price are point-in-time.** Re-run to refresh.

### FAQ

**Do I need an LCSC account or API key?** No. The actor reads public product pages only.

**Is this allowed?** The actor requests only public `product-detail` pages, which LCSC's `robots.txt` permits, at low volume. It collects factual product data (prices, specs, stock) — no personal data, no logged-in content.

**What if a code doesn't exist?** You get a record with `"error": "not_found"` for that code; the rest of the run continues.

**Can I get the datasheet file itself?** The actor returns the datasheet URL; download it separately if needed.

**Which currency?** USD, matching the international LCSC storefront.

**How many parts can I scrape?** As many as you provide. Keep `maxConcurrency` modest (default 5) for large BOMs.

# Actor input Schema

## `productCodes` (type: `array`):

One or more LCSC part codes, e.g. C1591, C25804, C7593. These are the 'LCSC Part #' shown on every product page and in a JLCPCB / LCSC BOM. Enter with or without the leading 'C'.

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

Optional. Full LCSC product-detail URLs (https://www.lcsc.com/product-detail/....html). Use this instead of, or in addition to, part codes.

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

Maximum number of parts to scrape. 0 means no limit (scrape everything you provided).

## `includePriceTiers` (type: `boolean`):

Include the full quantity-break price ladder (unit price at each quantity tier).

## `includeSpecs` (type: `boolean`):

Include the parametric attributes (resistance, capacitance, voltage, tolerance, etc.) as a specs object.

## `includeDatasheet` (type: `boolean`):

Include the manufacturer datasheet PDF URL when available.

## `includeImages` (type: `boolean`):

Include product image URLs.

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

Maximum parallel requests. Keep this low (default 5) to stay polite to LCSC and avoid rate limiting.

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

Proxy settings. LCSC product pages are lightly protected; the default Apify Proxy (datacenter) is usually enough. Switch to residential if you scrape very large lists.

## Actor input object example

```json
{
  "productCodes": [
    "C1591",
    "C25804"
  ],
  "productUrls": [
    "https://www.lcsc.com/product-detail/C1591.html"
  ],
  "maxItems": 0,
  "includePriceTiers": true,
  "includeSpecs": true,
  "includeDatasheet": true,
  "includeImages": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `parts` (type: `string`):

One item per LCSC part code: MPN, brand, description, category path, live stock, package, minimum order quantity, the full quantity price ladder, the parametric specs and the datasheet URL.

## `partsCsv` (type: `string`):

The same records as a spreadsheet-ready CSV — the shape you want for BOM costing.

## `overview` (type: `string`):

The columns most people read first: LCSC code, MPN, brand, description, category, stock, package, MOQ, price tiers and datasheet.

# 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 = {
    "productCodes": [
        "C1591",
        "C25804",
        "C7593"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("minty_modesty/lcsc-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 = { "productCodes": [
        "C1591",
        "C25804",
        "C7593",
    ] }

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

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

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

```

## CLI example

```bash
echo '{
  "productCodes": [
    "C1591",
    "C25804",
    "C7593"
  ]
}' |
apify call minty_modesty/lcsc-parts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=minty_modesty/lcsc-parts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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