# FPV Drone Parts Price Comparison Scraper (`statanow/fpv-drone-parts-price-scraper`) Actor

Compare FPV drone parts across PyroDrone and RaceDayQuads. Extract prices, stock, specs, variants, SKUs, and matched cross-store offers, then find the cheapest available option. Export structured data via Apify Dataset or API.

- **URL**: https://apify.com/statanow/fpv-drone-parts-price-scraper.md
- **Developed by:** [statanow](https://apify.com/statanow) (community)
- **Stats:** 2 total users, 1 monthly users, 42.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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/actors/running/actors-in-store.md#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

## 🏆 FPV Drone Parts Price Comparison Scraper

Compare **FPV drone parts prices, stock availability, variants, and technical specifications** across specialized FPV stores.

The Actor searches supported FPV retailers, extracts product data, normalizes product names and variants, and attempts to recognize when different stores sell the same component.

Matching offers are combined into one structured product record so you can quickly see:

- current prices
- stock availability
- product variants
- technical specifications
- SKUs and MPNs when available
- all matched store offers
- lowest and highest price
- cheapest offer
- best confirmed in-stock offer

Use it for **FPV drone parts price comparison, product research, competitor monitoring, purchasing tools, dashboards, FPV product databases, AI agents, and automation workflows**.

***

### 🚁 What can you do with this FPV scraper?

Use the Actor to:

- 💰 Compare FPV component prices across stores
- 🥇 Find the cheapest FPV parts offer
- ✅ Check whether products are in stock
- ⚙️ Extract technical specifications
- 🔢 Detect motor KV values
- 📐 Detect stator sizes such as `2207` and `2306`
- 🔋 Detect LiPo cell information such as `4S`, `6S`, or `2-6S`
- 🧩 Detect single-KV and multi-KV variants
- 🏷️ Normalize brands and product models
- 🆔 Extract SKU and MPN when available
- 🖼️ Extract product images
- 🔗 Get product URLs
- 🏪 See all matched retailer offers
- 📊 Get lowest and highest prices
- 📦 Export structured results from Apify Dataset
- 🔌 Access the data through the Apify API

***

### 🏪 Supported FPV stores

Current stable sources:

| Store | Product search | Product details | Cross-store comparison |
|---|---|---|---|
| PyroDrone | ✅ | ✅ | ✅ |
| RaceDayQuads | ✅ | ✅ | ✅ |

This Actor can be used as a **PyroDrone scraper**, **RaceDayQuads scraper**, and cross-store **FPV price comparison scraper**.

More FPV retailers may be added over time.

***

### 🧩 Cross-store product matching

FPV retailers often use slightly different titles for the same component.

For example:

```text
EMAX ECO II Series 2207-2400KV Motor
```

and:

```text
EMAX ECO II Series 2207 2400Kv Motor
```

may represent the same product.

The Actor uses FPV-aware normalization based on signals such as:

```text
brand
base model
category
KV
KV options
stator size
LiPo cell information
variant
SKU / MPN when available
```

When products are considered equivalent, their store offers are grouped into the same normalized result.

If the match is uncertain, the Actor keeps them separate instead of forcing an unreliable merge.

***

## 🚀 Quick start

### 1. Enter a product query

Open the Actor in Apify Console and enter the FPV component you want to search for.

Example:

```text
FlyFishRC Flash 2207 1850KV
```

Recommended input:

```json
{
  "mode": "search",
  "query": "FlyFishRC Flash 2207 1850KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "maxResults": 20,
  "includeDetails": true
}
```

### 2. Click **Start**

The Actor searches the selected stores and collects matching FPV products.

### 3. Open the Dataset

When the run finishes, open:

```text
Storage → Dataset
```

Each Dataset item represents one normalized FPV product.

***

### 🔎 Search examples

#### Search for a specific FPV motor

```json
{
  "mode": "search",
  "query": "FlyFishRC Flash 2207 1850KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "maxResults": 20,
  "includeDetails": true
}
```

#### Search by motor size and KV

```json
{
  "mode": "search",
  "query": "2207 1855KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "maxResults": 30,
  "includeDetails": true
}
```

#### Search for a specific product model

```json
{
  "mode": "search",
  "query": "EMAX ECO II 2207 2400KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "maxResults": 20,
  "includeDetails": true
}
```

#### Faster search without product detail pages

```json
{
  "mode": "search",
  "query": "2207 motor",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "maxResults": 20,
  "includeDetails": false
}
```

***

## ⬇️ Input options

| Input | Type | Description |
|---|---|---|
| `mode` | string | Scraping mode. Use `search` to search products |
| `query` | string | FPV product, component, brand, model, size, KV, or search phrase |
| `stores` | array | Stores to search |
| `maxResults` | integer | Maximum number of normalized products returned |
| `includeDetails` | boolean | Visit product pages for richer product data |
| `maxConcurrency` | integer | Maximum number of concurrent operations |
| `minRequestIntervalMs` | integer | Minimum interval between requests to the same store |
| `maxRetries` | integer | Retry limit for temporary request failures |
| `maxProductPagesPerStore` | integer | Maximum product detail pages visited per store |
| `proxyConfiguration` | object | Optional Apify Proxy configuration |

For most users, this is enough:

```json
{
  "mode": "search",
  "query": "2207 1855KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "maxResults": 20,
  "includeDetails": true
}
```

***

### `query`

Enter the FPV component you want to find.

Examples:

```text
2207 1855KV
```

```text
EMAX E3 2207
```

```text
FlyFishRC Flash 2207 1850KV
```

```text
EMAX ECO II 2207 2400KV
```

More specific queries usually produce cleaner results.

***

### `stores`

Select which FPV retailers should be searched.

Example:

```json
{
  "stores": [
    "pyrodrone",
    "racedayquads"
  ]
}
```

Using multiple stores enables cross-store price comparison.

***

### `maxResults`

Controls the maximum number of normalized products returned.

Example:

```json
{
  "maxResults": 20
}
```

Use a smaller value for quick searches and a larger value for broader product research.

***

### `includeDetails`

When enabled:

```json
{
  "includeDetails": true
}
```

the Actor visits individual product pages and attempts to collect richer data such as:

- description
- SKU
- MPN
- technical specifications
- stock status
- product variants
- detailed images

For a faster lightweight search:

```json
{
  "includeDetails": false
}
```

***

## ⬆️ Output

Each Dataset item represents one normalized FPV product.

A product may contain one or more store offers.

Example:

```json
{
  "productId": "01d4f493e3b30bec",
  "brand": "EMAX",
  "baseModel": "e3",
  "model": "EMAX E3 Series 2207 Motor - 1700KV/1900KV/2400KV",
  "category": "motor",
  "variant": {
    "kvOptions": [
      1700,
      1900,
      2400
    ],
    "stator": "2207"
  },
  "sku": "J1-14023-1900",
  "mpn": "23200",
  "image": "https://example.com/product-image.jpg",
  "specs": {
    "cellCount": "3-6S",
    "motorDimensions": "28.6 x 32.8 mm",
    "weight": "31.9g",
    "peakCurrent": "42A",
    "maxPower": "1050W"
  },
  "offers": [
    {
      "store": "PyroDrone",
      "storeKey": "pyrodrone",
      "price": 15.99,
      "currency": "USD",
      "inStock": true,
      "url": "https://pyrodrone.com/products/example"
    },
    {
      "store": "RaceDayQuads",
      "storeKey": "racedayquads",
      "price": 17.99,
      "currency": "USD",
      "inStock": true,
      "url": "https://www.racedayquads.com/products/example"
    }
  ],
  "lowestPrice": 15.99,
  "lowestInStockPrice": 15.99,
  "highestPrice": 17.99,
  "currency": "USD",
  "cheapestOffer": {
    "store": "PyroDrone",
    "price": 15.99,
    "inStock": true
  },
  "bestOffer": {
    "store": "PyroDrone",
    "price": 15.99,
    "inStock": true
  },
  "sourceCount": 2,
  "scrapedAt": "2026-09-08T17:49:44Z"
}
```

***

## 📊 Output fields

| Field | Description |
|---|---|
| `productId` | Normalized product identifier |
| `brand` | Product brand |
| `baseModel` | Normalized model used for matching |
| `model` | Human-readable product name |
| `category` | FPV component category |
| `variant` | KV, stator size, cell count, and variant information |
| `sku` | SKU when available |
| `mpn` | Manufacturer part number when available |
| `image` | Product image URL |
| `description` | Product description when available |
| `specs` | Technical product specifications |
| `offers` | Store offers matched to the product |
| `sources` | Retailer sources contributing to the product |
| `sourceIdentifiers` | Store-specific product identifiers |
| `lowestPrice` | Lowest detected price |
| `lowestInStockPrice` | Lowest confirmed in-stock price |
| `highestPrice` | Highest detected price |
| `currency` | Product currency |
| `cheapestOffer` | Lowest-priced offer |
| `bestOffer` | Best available offer |
| `sourceCount` | Number of matched stores |
| `scrapedAt` | Time the product was collected |

***

## 🥇 `cheapestOffer` vs `bestOffer`

These two fields serve different purposes.

#### `cheapestOffer`

The lowest price detected across matched stores.

#### `bestOffer`

The best currently available offer, with preference for confirmed in-stock products.

For example:

```text
Store A    $19.99    stock unknown
Store B    $21.49    in stock
```

The result may be:

```json
{
  "cheapestOffer": {
    "store": "Store A",
    "price": 19.99
  },
  "bestOffer": {
    "store": "Store B",
    "price": 21.49,
    "inStock": true
  }
}
```

This makes it easier to distinguish the absolute lowest price from the best currently purchasable option.

***

## 🔢 FPV motor variants

The Actor understands common FPV motor attributes.

### Single-KV example

```json
{
  "variant": {
    "kv": 1855,
    "stator": "2207"
  }
}
```

### Multi-KV example

```json
{
  "variant": {
    "kvOptions": [
      1700,
      1900,
      2400
    ],
    "stator": "2207"
  }
}
```

### LiPo cell compatibility

When available, product data may include values such as:

```text
4S
6S
3-6S
2-6S
```

***

## ⚙️ Technical specifications

When available, the Actor can extract FPV component specifications such as:

- KV
- input voltage
- cell count
- motor configuration
- stator diameter
- stator length
- motor dimensions
- shaft diameter
- mounting pattern
- weight
- internal resistance
- peak current
- maximum power
- propeller compatibility

Example:

```json
{
  "kv": "1855Kv",
  "inputVoltage": "4S Lipo",
  "configuration": "12N14P",
  "statorDiameter": "22mm",
  "statorLength": "7mm",
  "mountingPattern": "16x16mm",
  "weight": "31.6g"
}
```

Not every store exposes every specification.

Missing values are left unavailable rather than guessed.

***

## 🔌 FPV parts API

Every successful run stores the results in an Apify Dataset.

You can use the Actor as an **FPV components API** from Python, cURL, automation platforms, data pipelines, or AI agents.

### Python

Install the Apify client:

```bash
pip install apify-client
```

Example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor(
    "YOUR_USERNAME/fpv-drone-parts-price-scraper"
).call(
    run_input={
        "mode": "search",
        "query": "FlyFishRC Flash 2207 1850KV",
        "stores": [
            "pyrodrone",
            "racedayquads"
        ],
        "maxResults": 20,
        "includeDetails": True
    }
)

for item in client.dataset(
    run["defaultDatasetId"]
).iterate_items():
    print(
        item.get("brand"),
        item.get("model"),
        item.get("lowestPrice"),
        item.get("sourceCount")
    )
```

***

### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USERNAME~fpv-drone-parts-price-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "query": "FlyFishRC Flash 2207 1850KV",
    "stores": [
      "pyrodrone",
      "racedayquads"
    ],
    "maxResults": 20,
    "includeDetails": true
  }'
```

***

## 📦 Export FPV product data

After a successful run, open:

```text
Storage → Dataset
```

You can export the results in formats supported by Apify, including:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML

This makes the scraper useful for:

- spreadsheets
- databases
- FPV price comparison websites
- dashboards
- analytics
- product catalogs
- ETL pipelines
- automation workflows
- AI applications

***

## ⏰ Automate FPV price monitoring

Use **Apify Schedules** to run the Actor automatically.

Common workflows include:

- daily FPV parts price checks
- stock availability monitoring
- competitor price tracking
- price-drop monitoring
- FPV product catalog monitoring
- recurring purchasing research

For historical price analysis, save results from multiple scheduled runs in your own database or workflow.

***

## 💡 Use cases

### FPV price comparison websites

Build a searchable FPV product database and compare offers from multiple specialized stores.

### Find the cheapest FPV parts

Search a specific motor or component and identify the lowest-priced or best available offer.

### Compare PyroDrone and RaceDayQuads

Use the Actor to compare product prices and stock between PyroDrone and RaceDayQuads.

### FPV product research

Collect normalized product names, brands, variants, specifications, images, store URLs, and offers.

### Competitor monitoring

Track how FPV component prices and availability differ between retailers.

### FPV market research

Analyze product availability, price ranges, brands, specifications, and store coverage.

### AI agents and automation

Use structured FPV data in:

- AI product-search agents
- recommendation systems
- purchasing assistants
- automated research workflows
- dashboards
- data pipelines

***

## ❓ FAQ

### What does the FPV Drone Parts Price Comparison Scraper do?

It searches supported FPV retailers, extracts product data, normalizes matching products, and compares their prices and availability.

### Which FPV stores are supported?

The current stable sources are:

- PyroDrone
- RaceDayQuads

### Can it compare the same FPV product across stores?

Yes.

The Actor attempts to recognize equivalent products and combine their retailer offers into one normalized result.

### Why does a product have `sourceCount: 1`?

It means the Actor did not find a sufficiently reliable matching product from another selected store during that run.

The matching logic is intentionally conservative to reduce false matches.

### Can it find the cheapest FPV motor?

Yes.

Search by brand, model, stator size, KV, or a combination of attributes. When matching offers are found, the Actor returns the lowest detected price and the best available offer.

### Does it support FPV motor KV values?

Yes.

Examples include:

```text
1700KV
1800KV
1850KV
1855KV
1900KV
1980KV
2050KV
2400KV
2450KV
2755KV
```

### Does it support multiple KV options?

Yes.

A product with selectable motor variants may contain:

```json
{
  "kvOptions": [
    1700,
    1900,
    2400
  ]
}
```

### Does it detect motor sizes such as 2207 and 2306?

Yes.

Stator sizes can be extracted and used during product normalization and cross-store matching.

### Does it return stock status?

Yes, when reliable availability information is exposed by the retailer.

If stock status cannot be determined confidently, it may remain unknown.

### Does it return technical specifications?

Yes, when the retailer publishes them.

Different stores expose different amounts of product information.

### Does it return SKU and MPN?

Yes, when these identifiers are available.

### Can I export the results?

Yes.

Results are stored in an Apify Dataset and can be exported in multiple formats supported by Apify.

### Can I use it as an API?

Yes.

You can start runs through the Apify API and consume the resulting Dataset programmatically.

### Can I schedule automatic FPV price checks?

Yes.

Use Apify Schedules for recurring product, stock, and price monitoring.

### Is this an official PyroDrone or RaceDayQuads API?

No.

The Actor extracts publicly available product information from supported retailer websites.

***

## ⚠️ Data availability

Prices, stock status, product specifications, variants, and search results depend on the information available from each retailer at the time of the run.

Products can be added, removed, renamed, repriced, or go in and out of stock.

Cross-store matching is intentionally conservative. When two products cannot be matched confidently, they remain separate instead of being incorrectly merged.

***

## 🛠️ Support

If you encounter:

- an incorrect price
- an incorrect product match
- a missing product
- a missing specification
- a store extraction issue

open an issue on the Actor page and include:

```text
search query
affected store
product URL
expected result
```

This helps diagnose store-specific issues faster.

# Actor input Schema

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

Search store catalogs, crawl supplied URLs, or crawl store catalog/category entry points.

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

Example: 2207 1855KV, ELRS receiver, 5 inch frame.

## `stores` (type: `array`):

Stores to crawl.

## `startUrls` (type: `array`):

Used in URLs mode. Product, category, collection, or search URLs are supported.

## `maxResults` (type: `integer`):

Global limit across all stores.

## `includeDetails` (type: `boolean`):

Recommended. Enables specs, SKU/MPN, more reliable stock, and normalized matching.

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

Global worker count. Requests to the same store are additionally rate-limited.

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

Apify Proxy is recommended for production runs.

## `minRequestIntervalMs` (type: `integer`):

Minimum spacing between request starts to the same store. Increase if you see HTTP 429.

## `maxRetries` (type: `integer`):

Retries network/HTTP errors. HTTP 429 honors Retry-After when present and uses exponential cooldown.

## `enableShopifySuggestFallback` (type: `boolean`):

If a Shopify HTML search page has no product cards, try Shopify predictive-search JSON automatically.

## `maxProductPagesPerStore` (type: `integer`):

Caps expensive product-detail requests per retailer. Listing offers are still collected beyond this cap.

## Actor input object example

```json
{
  "mode": "search",
  "query": "2207 1855KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "startUrls": [],
  "maxResults": 10,
  "includeDetails": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "minRequestIntervalMs": 1200,
  "maxRetries": 2,
  "enableShopifySuggestFallback": true,
  "maxProductPagesPerStore": 5
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing normalized FPV products, cross-store offers, prices, stock, variants, and technical specifications.

## `summary` (type: `string`):

Summary of the run, selected stores, product counts, offer counts, and per-store crawl statistics.

# 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 = {
    "mode": "search",
    "query": "2207 1855KV",
    "stores": [
        "pyrodrone",
        "racedayquads"
    ],
    "startUrls": [],
    "maxResults": 10,
    "includeDetails": false,
    "maxConcurrency": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "minRequestIntervalMs": 1200,
    "maxRetries": 2,
    "enableShopifySuggestFallback": true,
    "maxProductPagesPerStore": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("statanow/fpv-drone-parts-price-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 = {
    "mode": "search",
    "query": "2207 1855KV",
    "stores": [
        "pyrodrone",
        "racedayquads",
    ],
    "startUrls": [],
    "maxResults": 10,
    "includeDetails": False,
    "maxConcurrency": 2,
    "proxyConfiguration": { "useApifyProxy": False },
    "minRequestIntervalMs": 1200,
    "maxRetries": 2,
    "enableShopifySuggestFallback": True,
    "maxProductPagesPerStore": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("statanow/fpv-drone-parts-price-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 '{
  "mode": "search",
  "query": "2207 1855KV",
  "stores": [
    "pyrodrone",
    "racedayquads"
  ],
  "startUrls": [],
  "maxResults": 10,
  "includeDetails": false,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "minRequestIntervalMs": 1200,
  "maxRetries": 2,
  "enableShopifySuggestFallback": true,
  "maxProductPagesPerStore": 5
}' |
apify call statanow/fpv-drone-parts-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,statanow/fpv-drone-parts-price-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/XoObPIYFdo8RjbEj3/builds/rZ93KPBxtr1tIIgIQ/openapi.json