# LCSC Listings Scraper (`piotrv1001/lcsc-listings-scraper`) Actor The LCSC Scraper extracts electronic component listings from LCSC.com by search term, part number, or category, capturing LCSC part codes, MPNs, full quantity-break pricing, live stock, MOQ, datasheets, and parametric specs โ€” ideal for BOM costing, JLCPCB sourcing, and price comparison. - **URL**: https://apify.com/piotrv1001/lcsc-listings-scraper.md - **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community) - **Categories:** E-commerce, Automation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing from $4.00 / 1,000 product listings 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use 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 Scraper - Electronic Component Prices & Stock Extract **electronic component data from LCSC Electronics** at scale. The **LCSC Scraper** pulls part numbers, **full quantity-break pricing**, live warehouse stock, datasheets and complete parametric specs into clean, structured JSON โ€” ready for BOM costing, price comparison and stock monitoring. LCSC is the price-leading distributor behind [JLCPCB](https://jlcpcb.com/) assembly, and its **C-numbers** are the join key for JLCPCB BOMs. This scraper makes that catalog queryable, exportable and schedulable โ€” with API access, scheduling, integrations and monitoring on the [Apify platform](https://apify.com). ### โœจ Features - ๐Ÿ’ฐ **Full price ladder** โ€“ every quantity break (1 / 10 / 30 / 100 / 500 / 1,000+) in USD, not just the headline price. - ๐Ÿ“ฆ **Live stock** โ€“ total, domestic and overseas warehouse quantities, plus MOQ, order multiple and reel/packet quantities. - ๐Ÿ”ฌ **Complete parametric specs** โ€“ the whole datasheet parameter table (voltage, tolerance, temperature range, package, and dozens more per part). - ๐Ÿงพ **BOM lookup mode** โ€“ paste a list of LCSC part codes or manufacturer part numbers and get them priced in seconds. These also return **tariff/HTS codes** for 7 regions and **schematic + PCB footprint images**. - ๐Ÿ“‚ **Whole-category exports** โ€“ point it at any LCSC category page and export it in full; large categories are split up automatically so you go far past the site's own paging limit. - โœ… **In-stock filter, RoHS, ECCN, lifecycle status** and direct datasheet links on every record. - โšก **Fast and cheap** โ€“ thousands of parts per minute, no proxies required. ### ๐Ÿ’ก Why use the LCSC Scraper? - **BOM cost rollup** โ€“ price a complete bill of materials with real quantity breaks instead of single-unit prices. - **Price arbitrage** โ€“ compare LCSC against Digi-Key, Mouser or Farnell and find where the savings are. - **JLCPCB sourcing** โ€“ check availability of basic and extended parts before you commit to an assembly order. - **Stock monitoring** โ€“ schedule a daily run and get alerted when a critical part drops below a threshold. - **Parametric part search** โ€“ find every 0603 resistor within a tolerance and power band, with prices attached. - **Trade compliance** โ€“ HTS/tariff codes for the US, EU (TARIC), CN, CA, MX, BR and IN on part lookups. ### ๐Ÿ› ๏ธ How to use the LCSC Scraper 1. **Choose what to scrape** โ€“ enter a search term (e.g. `STM32`), a list of part numbers, an LCSC category URL, or any combination. 2. **Set your limit** โ€“ pick how many products to save with **Maximum items**. Start small to preview the data. 3. **Optionally filter** โ€“ tick **In-stock parts only** if you only care about parts you can actually buy today. 4. **Run it** โ€“ click **Start**. Results appear in the **Output** tab within seconds. 5. **Export or integrate** โ€“ download as JSON, CSV, Excel or HTML, or pull it via the [Apify API](https://docs.apify.com/api/v2). ### ๐Ÿ“ฅ Input | Field | Type | Description | | -------------------- | ------- | ---------------------------------------------------------------------------------------- | | `search` | string | Keyword or part-number fragment, e.g. `STM32`, `AMS1117`, `0603 capacitor`. | | `partNumbers` | array | LCSC part codes (`C7420`) or manufacturer part numbers (`STM32F103C8T6`). Best for BOMs. | | `categoryUrls` | array | LCSC category pages, e.g. `https://www.lcsc.com/category/970.html`. | | `inStockOnly` | boolean | Only return parts currently in the warehouse. Default `false`. | | `maxItems` | integer | Maximum products to save. Default `50`. | | `proxyConfiguration` | object | Optional proxy settings. The default works fine. | Example input: ```json { "search": "STM32", "partNumbers": ["C7420", "STM32F103C8T6"], "inStockOnly": true, "maxItems": 200 } ```` ### ๐Ÿ“Š Sample output data You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. ```json [ { "partCode": "C529330", "mpn": "STM32G030F6P6TR", "brand": "ST", "name": "Arm Cortex-M0+ 32-bit MCU, up to 64 KB Flash, 8 KB RAM, 2x USART, timers, ADC, comm. I/Fs, 2.0-3.6V", "description": "ARM Cortex-M0+ 32 Bit 64MHz 17 TSSOP-20 Microcontrollers RoHS", "url": "https://www.lcsc.com/product-detail/C529330.html", "categoryPath": "Integrated Circuits (ICs) > Embedded > Microcontrollers", "package": "TSSOP-20", "packaging": "Tape & Reel (TR)", "stock": 8450, "inStock": true, "prices": [ { "quantity": 1, "priceUsd": 1.2305 }, { "quantity": 10, "priceUsd": 1.0938 }, { "quantity": 100, "priceUsd": 0.9196 }, { "quantity": 1000, "priceUsd": 0.8789 } ], "priceUsdMin": 0.8789, "priceUsdAtMoq": 1.2305, "minOrderQuantity": 1, "packetQuantity": 2500, "rohs": true, "lifecycle": "normal", "eccn": "5A992C", "datasheetUrl": "https://datasheet.lcsc.com/datasheet/pdf/753f35401d4598e355b1dd55569495e1.pdf", "imageUrl": "https://assets.lcsc.com/images/lcsc/900x900/20230104_STMicroelectronics-STM32G030F6P6TR_C529330_front.jpg", "specs": { "ADC (Bit)": "12bit", "Operating Temperature": "-40โ„ƒ~+85โ„ƒ", "Voltage - Supply": "2V~3.6V", "Program Memory Type": "FLASH" } } ] ``` ### ๐Ÿ“‹ Data fields | Field | Description | | --------------------------------------------------------------------------- | ---------------------------------------------------------------------- | | `partCode` | LCSC part number (C-number) โ€” the JLCPCB BOM join key | | `mpn` | Manufacturer part number | | `brand` | Manufacturer name | | `name`, `description` | Product name and summary description | | `url` | LCSC product page URL | | `category`, `categoryPath` | Full category breadcrumb, as array and joined string | | `package`, `packaging` | Component package (e.g. `TSSOP-20`) and packaging (e.g. `Tape & Reel`) | | `stock`, `stockDomestic`, `stockOverseas`, `inStock` | Warehouse quantities and availability flag | | `prices` | Full quantity-break ladder: `[{ quantity, priceUsd }]` | | `priceUsdMin`, `priceUsdAtMoq` | Best bulk price and the price at minimum order quantity | | `minOrderQuantity`, `orderMultiple`, `packetQuantity`, `packetUnit`, `unit` | Ordering rules | | `isReel`, `reelPriceUsd` | Reel packaging availability and surcharge | | `rohs`, `lifecycle`, `eccn`, `hasBattery`, `weightGrams` | Compliance and logistics attributes | | `datasheetUrl`, `imageUrl`, `images` | Datasheet PDF and product photos | | `specs` | Full parametric table as a `{ name: value }` object | | `htsCodes` | Tariff/HTS codes per region *(part-number lookups only)* | | `schematicSvgUrl`, `pcbSvgUrl` | Schematic symbol and PCB footprint images *(part-number lookups only)* | ### ๐Ÿ’ต How much does it cost to scrape LCSC? This Actor uses **pay per event** pricing โ€” you pay for the data you get, not for compute time. | Event | Price | When it's charged | | --------------- | ---------- | ---------------------------------------------------------------------------------- | | Actor start | **$0.02** | Once per run | | Product listing | **$0.004** | Per product from a search term or category URL | | Part lookup | **$0.008** | Per product looked up by part number (includes HTS codes and schematic/PCB images) | Examples: - A **50-part BOM lookup** costs about **$0.42**. - Exporting **1,000 products** from a category costs about **$4.02**. - Exporting **10,000 products** costs about **$40.02**. With the Apify Free plan's **$5 of monthly credit** you can scrape roughly **1,200 products per month at no cost**. ### ๐Ÿ’ก Tips - **Start with a low `maxItems`** to preview the output shape before committing to a large export. - **Use `partNumbers` for BOMs.** It resolves manufacturer part numbers to LCSC C-numbers automatically and returns the richest record. - **Use `categoryUrls` for market research.** Grab the URL straight from your browser's address bar on any LCSC category page. - **Tick `inStockOnly` for sourcing.** Most of the LCSC catalog is sourcing data rather than warehouse inventory, so this dramatically cuts noise (and cost) when you only want buyable parts. - **Schedule a daily run** and connect it to Slack, Google Sheets or a webhook via [Apify Integrations](https://apify.com/integrations) to monitor price and stock changes. ### โ“ FAQ **Are the prices in USD?** Yes โ€” every price in `prices`, `priceUsdMin`, `priceUsdAtMoq` and `reelPriceUsd` is in US dollars. **Can I export the entire LCSC catalog?** Yes. Add the category URLs you want and raise `maxItems`. Oversized categories are automatically split into smaller batches behind the scenes, so you are not limited by the site's own paging cap. **Why did a part number return nothing?** Some manufacturer part numbers are not carried by LCSC, or are listed under a slightly different suffix (e.g. `...TR` for tape and reel). Try the LCSC C-number instead, which is always exact. **Why are `htsCodes` and the SVG links empty on some records?** Those fields are only available for parts fetched via the `partNumbers` input. Products from a search term or category export do not include them. **Is scraping LCSC legal?** This Actor collects publicly available product information only, and does not collect personal data. You are responsible for how you use the data โ€” check LCSC's terms and consult a lawyer if you plan to republish it. LCSC also offers an official partner API for account holders, which may be the better fit if you need order placement. ### ๐Ÿ†˜ Support Found a bug or need a field that isn't here yet? Open an issue on the **Issues** tab and we'll take a look. Custom scraping solutions are available on request. # Actor input Schema ## `search` (type: `string`): Keyword or part-number fragment to search the LCSC catalog for, e.g. `STM32`, `AMS1117`, `0603 capacitor`. ## `partNumbers` (type: `array`): Look up specific parts by LCSC part code (`C7420`) or manufacturer part number (`STM32F103C8T6`). Ideal for pricing a BOM. Parts looked up this way also come with tariff/HTS codes and schematic & PCB footprint images. ## `categoryUrls` (type: `array`): LCSC category pages to scrape in full, e.g. `https://www.lcsc.com/category/970.html`. Large categories are split up automatically so you can go well past the site's own paging limit. ## `inStockOnly` (type: `boolean`): Return only parts currently available in the warehouse. Applies to search terms and category URLs. ## `maxItems` (type: `integer`): Maximum number of products to save. Keep it low for a quick test, raise it for a full export. ## `proxyConfiguration` (type: `object`): Proxy settings. The default works fine - only change it if you need traffic from a specific country. ## Actor input object example ```json { "search": "STM32", "inStockOnly": false, "maxItems": 50, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `results` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "search": "STM32" }; // Run the Actor and wait for it to finish const run = await client.actor("piotrv1001/lcsc-listings-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "search": "STM32" } # Run the Actor and wait for it to finish run = client.actor("piotrv1001/lcsc-listings-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 '{ "search": "STM32" }' | apify call piotrv1001/lcsc-listings-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=piotrv1001/lcsc-listings-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "LCSC Listings Scraper", "description": "The LCSC Scraper extracts electronic component listings from LCSC.com by search term, part number, or category, capturing LCSC part codes, MPNs, full quantity-break pricing, live stock, MOQ, datasheets, and parametric specs โ€” ideal for BOM costing, JLCPCB sourcing, and price comparison.", "version": "0.0", "x-build-id": "r5JK2A5IYUEbMUjC0" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/piotrv1001~lcsc-listings-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-piotrv1001-lcsc-listings-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/piotrv1001~lcsc-listings-scraper/runs": { "post": { "operationId": "runs-sync-piotrv1001-lcsc-listings-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/piotrv1001~lcsc-listings-scraper/run-sync": { "post": { "operationId": "run-sync-piotrv1001-lcsc-listings-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "search": { "title": "Search term", "type": "string", "description": "Keyword or part-number fragment to search the LCSC catalog for, e.g. `STM32`, `AMS1117`, `0603 capacitor`." }, "partNumbers": { "title": "Part numbers", "type": "array", "description": "Look up specific parts by LCSC part code (`C7420`) or manufacturer part number (`STM32F103C8T6`). Ideal for pricing a BOM. Parts looked up this way also come with tariff/HTS codes and schematic & PCB footprint images.", "items": { "type": "string" } }, "categoryUrls": { "title": "Category URLs", "type": "array", "description": "LCSC category pages to scrape in full, e.g. `https://www.lcsc.com/category/970.html`. Large categories are split up automatically so you can go well past the site's own paging limit.", "items": { "type": "object", "required": [ "url" ], "properties": { "url": { "type": "string", "title": "URL of a web page", "format": "uri" } } } }, "inStockOnly": { "title": "In-stock parts only", "type": "boolean", "description": "Return only parts currently available in the warehouse. Applies to search terms and category URLs.", "default": false }, "maxItems": { "title": "Maximum items", "minimum": 1, "type": "integer", "description": "Maximum number of products to save. Keep it low for a quick test, raise it for a full export.", "default": 50 }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "Proxy settings. The default works fine - only change it if you need traffic from a specific country.", "default": { "useApifyProxy": false } } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```