DEV Community: ReventaData

How to Scrape eBay Spain Listings and Prices with Python

ReventaData — Mon, 02 Nov 2026 10:06:15 +0000

By the end of this tutorial, you will have a short Python script that turns an ebay.es search into structured rows: title, price in EUR, condition, auction state and bid count, shipping cost, ship-from country, and whether the seller is a private person or a business.

eBay Spain puts a JavaScript browser challenge in front of its search pages. In testing on 2026-08-22, plain, datacenter and residential requests all got the same canned error page, while Apify Unblocker returned real result pages.

In this guide, we use Python and the Apify Actor eBay Spain Scraper (reventadata/ebay-scraper). You will configure a search, run the Actor and read the rows. The rows shown below are a sample from a capture dated 2026-08-22, parsed with the Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn an ebay.es search into one row per active listing. Each row carries the listingId and a clean url, the title, price in EUR, eBay's own condition wording, sellerType (private or business), the auction fields (isAuction, bidCount, timeLeft, endsAt), the shipping fields and shipFrom.

Note: Active listings only. Per the README, sold and completed listings are not available: eBay's sold filters send an anonymous visitor to a sign-in page. The README also states that eBay's robots.txt disallows the /sch/ search path this Actor reads, so you can weigh that yourself.

Example use case: Suppose you want used iPhones from private sellers between 200 and 600 EUR. You would set searchTerms: ["iphone 15 pro"], condition: "used", sellerType: "private", minPrice: 200 and maxPrice: 600.

Step 1: Access eBay Spain Scraper

Go to the eBay Spain Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the search

The main input is searchTerms, and it is required: one or more keywords, typed exactly as you would type them into eBay's own search box. Each term is searched in turn, and every row records the term it came from in keyword.

Two inputs bound the run:

maxItems (default 240) caps the rows saved across all terms.
maxPages (1 to 500, default 500) caps the pages read per term. The Actor already stops at the real end of a query, worked out from eBay's own result count.

itemsPerPage sets how many listings eBay puts on each page: "60", "120" or "240" (the default). Per the input description, 240 makes a quarter of the requests that 60 makes, for the same rows.

Here is the setup. It searches iphone, reads one page of 60 listings and saves at most 10 rows:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the search: one keyword, one page of 60, at most 10 rows
run_input = {
    "searchTerms": ["iphone"],
    "itemsPerPage": "60",
    "maxPages": 1,
    "maxItems": 10,
}

No proxy setting exists: the Actor always fetches through Apify Unblocker.

Step 3: Add optional filters

Three filters go to eBay itself and change the results it serves; one runs on the rows after fetching:

Parameter	Values	Where it runs
`condition`	`any`, `new`, `refurbished`, `used`, `forParts`	eBay's own condition filter
`listingType`	`any`, `auction`, `buyItNow`	eBay's own auction / Buy It Now filter
`minPrice` / `maxPrice`	whole euros	eBay's own price filter; omitted when empty
`sellerType`	`any`, `private`, `business`	On the rows, from the seller line eBay prints on each card

Three example combinations:

Private sellers only: sellerType: "private", any term.
Live auctions: listingType: "auction"; each row then carries bidCount, and timeLeft when eBay prints one.
Refurbished in a price band: condition: "refurbished", minPrice: 300, maxPrice: 500.

⚠️ A value outside the lists above is refused before the run starts. A minPrice above maxPrice stops the run with an error at its start.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/ebay-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting eBay Spain extraction...")
run = client.actor("reventadata/ebay-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved listings
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} listings.\n")

Behind the scenes:

The Actor builds the ebay.es search URL from your term and filters and fetches each page through Apify Unblocker.
It reads eBay's results heading first. When eBay found nothing, the page still shows unrelated listings; none of it is collected.
It parses each listing card, skips eBay's own promo cards, applies sellerType, and saves the rows.
It stops at maxItems, at maxPages, at the last real page from eBay's count, or at a page that adds no new listing.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    kind = "current bid" if item["isAuction"] else "price"
    print(item["title"])
    print(f"  {kind}: {item['price']} {item['currency']}")
    print(f"  Condition: {item.get('condition')}")
    print(f"  Seller type: {item.get('sellerType')}")
    print(f"  Shipping: {item.get('shippingText') or 'not shown'}")
    print(f"  Link: {item['url']}")
    print("-" * 40)

Here are two rows, a sample from a capture dated 2026-08-22 (an iphone search) parsed with the Actor's own parser. keyword and page come from the search loop; here they are the values passed to the parser. First, a fixed-price listing from a business seller:

{
    "listingId": "147520935178",
    "title": "Apple Iphone 15 Black 128GB (ohne Simlock)",
    "url": "https://www.ebay.es/itm/147520935178",
    "keyword": "iphone",
    "page": 1,
    "condition": "Usado",
    "sellerType": "business",
    "price": 369.0,
    "currency": "EUR",
    "buyItNowPrice": null,
    "isAuction": false,
    "bidCount": null,
    "timeLeft": null,
    "endsAt": null,
    "isBuyItNow": true,
    "acceptsBestOffer": false,
    "shippingCost": 0.0,
    "freeShipping": true,
    "shippingText": "Envío gratis",
    "shipFrom": "Austria",
    "energyClass": "B",
    "sellerUsername": "marketxpres",
    "sellerFeedbackPercent": 100.0,
    "sellerFeedbackCount": 169
}

Second, an auction from a private seller that also offers Buy It Now:

{
    "listingId": "278302959365",
    "title": "iPhone 17",
    "url": "https://www.ebay.es/itm/278302959365",
    "keyword": "iphone",
    "page": 1,
    "condition": "Usado",
    "sellerType": "private",
    "price": 400.0,
    "currency": "EUR",
    "buyItNowPrice": 1000.0,
    "isAuction": true,
    "bidCount": 39,
    "timeLeft": "Quedan 2 d 3 h",
    "endsAt": "(Lunes, 23:25)",
    "isBuyItNow": true,
    "acceptsBestOffer": false,
    "shippingCost": 15.0,
    "freeShipping": false,
    "shippingText": "+ 15,00 EUR de envío",
    "shipFrom": null,
    "energyClass": null
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

price: means two things, and isAuction tells you which. On a fixed-price listing it is the asking price; on an auction it is the current bid. In the sample, 400 EUR is the bid after 39 bids, and buyItNowPrice holds the seller's fixed 1,000 EUR.
sellerType: private or business, from eBay's own card line (Vendedor particular / Vendedor profesional).
sellerUsername, sellerFeedbackPercent, sellerFeedbackCount: business sellers only. On a private seller's row the keys are absent, not null, as in the auction above.
condition: eBay's Spanish wording, verbatim (Usado, Reacondicionado, Solo piezas), not mapped to a grade.
shippingCost, freeShipping, shippingText: a number, a flag and eBay's own phrase. shipFrom is filled only when the card says desde <country>.
timeLeft and endsAt: eBay's phrases. endsAt is a weekday and clock time, not a date.
energyClass: the EU energy label, A to G, not a condition grade.

Pro tips

Leave itemsPerPage at 240 for real runs. The same rows come back in a quarter of the requests 60 needs. The 60 above only keeps the first test small.
Filter on eBay first. condition, listingType and the price bounds change what eBay serves. sellerType only drops rows after the fetch, so pair it with a narrow term.
Batch terms in one run. Put several keywords in searchTerms. A listing saved under one term is not saved again under a later one.
Treat price with isAuction. Before averaging prices, split auctions from fixed-price rows, or use buyItNowPrice where an auction has one.
Start small. Keep maxPages: 1 and maxItems: 10 until your downstream code handles the fields, then raise them.
Read the log on a short run. eBay sometimes answers a URL with a full-size page that carries no listing at all. The Actor retries it, and if a page is still skipped after every retry, the log says how many pages were skipped, so a short dataset is never silent. Re-running usually picks those listings up.

Troubleshooting

Zero rows: a run that is blocked, skips a page after every retry, cannot parse a results page or runs out of time ends FAILED. If pages loaded normally but your filters dropped everything, or eBay's own heading says zero results for the term, the run ends SUCCEEDED with an empty dataset and a status message saying so.
Run stops at once: searchTerms was empty, or minPrice is above maxPrice.
Fewer rows than expected: read the lines near the end of the log: Rejected N: seller is not private counts rows sellerType dropped, and a line reports pages skipped after every retry. From Python: client.log(run.id).get().
No sold prices: not a bug. The Actor covers active listings only.
shipFrom is often null: normal. eBay prints desde <country> only on some cards; a domestic listing usually has none.

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To repeat a search, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

What are you planning to track on eBay Spain? Drop a comment! 💬

How to Scrape Back Market Spain Refurbished Prices with Python

ReventaData — Mon, 02 Nov 2026 10:05:26 +0000

By the end of this tutorial, you will have a short Python script that turns a Back Market Spain category into structured rows: model name, starting price, the price the device cost new, star rating, review count and condition grade.

Back Market sells refurbished electronics, and backmarket.es sits behind Cloudflare Bot Management. In recon on 2026-08-22, requests with no proxy, datacenter and residential proxies got an error body instead of a page; Apify Unblocker returned the page.

In this guide, we use Python and the Apify Actor Back Market Spain Scraper (reventadata/backmarket-scraper). You will pick a category, run the Actor and narrow rows by price and brand. The sample row below is a sample from a capture dated 2026-09-18, parsed with the Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn one Back Market category page into one row per product model. A card on that page is a model, "iPhone 16", not a merchant offer. Each row carries id, title, url, brand, model, price (the cheapest variant, the site's Desde), priceWhenNew, rating, ratingCount, availableColors, grade, availableStock and warrantyMonths.

Note: Back Market names no merchant on its category or product pages, so rows carry no seller data. The payload holds a sellerId; the Actor never reads it.

Example use case: Suppose you want refurbished iPhones that start between 300 and 700 EUR. You would put the iPhone category URL in categories, set minPrice: 300 and maxPrice: 700, and every saved row would have a starting price inside that band, with its price new beside it.

Step 1: Access Back Market Spain Scraper

Go to the Back Market Spain Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the category

The one required input is categories: one or more Back Market Spain category URLs, copied from the address bar. A category is a slug and the UUID after it, for example iphone/aabc736a-cb66-4ac0-a3b7-0f449781ed39; a slug alone is an error. The Actor checks every category before its first request.

There is no free-text search input: backmarket.es's robots.txt disallows */search, so the Actor browses categories only.

Each category page holds 31 models. maxPages (1 to 33, default 33) bounds pages per category, and maxItems (default 300) caps rows across all categories.

Here is the setup. It reads one page of the iPhone category and saves at most 10 rows:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the category: one page, at most 10 rows
run_input = {
    "categories": [
        "https://www.backmarket.es/es-es/l/iphone/aabc736a-cb66-4ac0-a3b7-0f449781ed39"
    ],
    "maxPages": 1,
    "maxItems": 10,
}

No proxy setting exists: the Actor always fetches through Apify Unblocker, the one transport that reached the site in recon.

Step 3: Add optional filters

Back Market's own price, storage, model and colour controls write a URL fragment (#price=600&price=900). A fragment never leaves the browser, and the query-string spelling of the same filters is ignored by the server. So the Actor sends only ?p=<n> and applies its filters to the rows it read:

Parameter	Type	What it keeps
`minPrice` / `maxPrice`	integer	Rows whose starting price, in whole euros, is inside the bound.
`brands`	array	Rows whose brand matches, using the site's lowercase value such as `apple` or `samsung`, case-insensitive.
`fetchProductDetails`	boolean	Not a filter: opens each model's product page for its variant price matrix. Off by default.

⚠️ minPrice greater than maxPrice stops the run with an error at its start. A negative price is refused before the run starts.

Step 4: Run the Actor

Start the run with .call(). It starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting Back Market extraction...")
run = client.actor("reventadata/backmarket-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved models
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} models.\n")

Behind the scenes:

The Actor builds the category URL with ?p=N and fetches each page through Apify Unblocker.
It reads the models from the page's embedded __NUXT_DATA__ payload, keeps the 31 grid records and skips the recommendation carousel, applies your filters and saves the rows.
It stops at maxItems, at maxPages, or once it has every model the site reports for the category.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    print(item["title"], "|", item.get("grade"))
    print(f"  From {item['price']} EUR, new {item['priceWhenNew']} EUR")
    if item.get("price") and item.get("priceWhenNew"):
        print(f"  {1 - item['price'] / item['priceWhenNew']:.0%} below the price new")
    print(f"  Rating {item.get('rating')} from {item.get('ratingCount')} reviews")
    print("-" * 40)

Here is one row, a sample from a capture dated 2026-09-18 (page 1 of the iPhone category) parsed with the Actor's own parser:

{
    "id": "5119391",
    "title": "iPhone 16",
    "url": "https://www.backmarket.es/es-es/p/iphone-16",
    "category": "iphone",
    "brand": "apple",
    "productType": "Smartphone",
    "model": "iphone 16",
    "variationId": "0e3441cf-37af-429e-973f-218cb3c1fd63",
    "price": 584.0,
    "priceWhenNew": 1009.0,
    "currency": "EUR",
    "isStartingFromPrice": true,
    "rating": 4.59,
    "ratingCount": 14802,
    "availableColors": [
        "Azul ultramar",
        "Blanco",
        "Negro",
        "Rosa",
        "Teal",
        "Ultramarine",
        "Verde azulado"
    ],
    "imageUrl": "https://d2e6ccujb3mkqf.cloudfront.net/2d99b692-a008-4345-8196-fea4cf5e4096-1_44974392-bda8-41f2-835b-2410a15bd88a.jpg",
    "grade": "Excelente",
    "availableStock": 29,
    "warrantyMonths": 24
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

price and isStartingFromPrice: the cheapest variant of the model, in EUR, not the price of one device. The real price depends on grade, battery, storage, colour and SIM. All 31 captured rows had isStartingFromPrice: true, and starting prices ran from 81.99 (iPhone 7) to 1,180 (iPhone 17 Pro Max).
priceWhenNew: what the site says the device cost new, taken from the card. In the capture, the starting price sat between 20% (iPhone 17 Pro Max) and 78% (iPhone 12) below it; that percentage is our arithmetic, not a site field.
grade, availableStock, warrantyMonths: they describe the listing behind the starting price. Grades are the site's Spanish words: of 31 rows, 17 Correcto, 8 Muy bueno, 5 Excelente, 1 Prémium. All 31 had 24 months.
rating, ratingCount: two decimals out of 5. 30 of 31 were rated, 4.07 to 4.68; iPhone 15 Pro showed 0 with 0 reviews.
variationId: the priced listing's public UUID; it changes when another offer becomes the cheapest.

Pro tips

Use leaf categories. The site serves at most 1,000 models per category: 32 pages of 31 plus a page of 8. Past that it shows 0 productos, even on electronica, which reported 6,588 on page 1 (2026-09-18). The Actor stops at page 33 and logs the site's count, so for a large category, run its sub-categories.
Batch categories in one run. Put several URLs in categories. A model saved under one is not saved again under the next.
Turn on details only when you need them. fetchProductDetails adds currentPrice, grades, batteryOptions, storageOptions, colorOptions and simOptions, each option with a label, the site's value and a price, at one extra page request per model. A product page that fails keeps its listing row.
Filters narrow what you receive, not what is read. A tight maxPrice on a large category still walks its pages; set maxPages to bound it.
Start small. Keep maxPages: 1 and maxItems: 10 until your code handles the fields.

Troubleshooting

Zero rows: the status message names the reason. A page that failed or a category that could not be resolved ends the run FAILED. Rows rejected by your filters, or a category the site itself reports as 0 productos, end it SUCCEEDED with an empty dataset.
Run stops at once: a category is a slug without its UUID, or minPrice is above maxPrice.
Fewer rows than expected: read the end of the log. Rejected N: ... lines count each filter's drops, and Pushed N row(s). the saved rows. From Python: client.log(run.id).get().
A large category stops at 1,000: the site's window, not a fault. Use sub-categories.

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To track prices, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which refurbished categories are you planning to track on Back Market? Drop a comment! 💬

How to Scrape Amazon Search Results with Python and an Apify Actor

ReventaData — Mon, 02 Nov 2026 10:05:00 +0000

By the end of this tutorial, you will have a short Python script that turns an Amazon search into structured JSON: one row per product with its ASIN, title, current price, strikethrough list price, discount percentage, star rating, review count, a Prime flag, a sponsored flag and a clean /dp/ link.

We use the Apify Actor Amazon Product & Price Scraper (reventadata/amazon-scraper). It is for developers who track prices, compare products by rating, or watch what Amazon shows for a keyword, and would rather read rows than result cards. It covers 9 Amazon marketplaces: the US, UK, Germany, Spain, France, Italy, Canada, Japan and India.

You will learn how to configure a search, run it from Python, read every field, and filter the results before they reach your dataset.

⏱️ Time: about 10 minutes for the setup.

Prerequisites

You need three things:

An Apify account. You can sign up for free.
Python 3.11 or newer, which apify-client requires.
Your API token, from the Integrations settings page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

Then keep the token in an environment variable, never in the script:

export APIFY_API_TOKEN="<your token>"

No scraping code is required: the Actor handles fetching and parsing.

What you'll achieve

You will get a dataset with one row per search result, for the keywords and marketplace you choose. Each row holds the fields printed on Amazon's result card: price in the marketplace's currency, list price when Amazon shows one crossed out, the discount computed from those two, rating, review count, Prime and sponsored flags, and the product image.

Example use case: you follow business laptops on amazon.com. You search thinkpad, keep rows rated 4 stars or more, drop sponsored placements, and compare prices against list prices. That is the configuration this tutorial builds up.

The sample rows below come from a capture of amazon.com page 1 for "thinkpad", dated 2026-10-22, read with the Actor's own parser. They are not from a run started for this post.

Step 1: Access Amazon Product & Price Scraper

Go to the Amazon Product & Price Scraper page on Apify Store. If you prefer clicking to coding, Apify Console has the same fields in the Actor's Input tab, and you press Start there.

In this tutorial we drive it from Python, so the same search is easy to repeat.

Step 2: Configure the search

The main input is searchQueries: a list of keywords, each searched on its own. Pick the marketplace with country, one of US, UK, DE, ES, FR, IT, CA, JP or IN. Prices come back in that marketplace's currency: USD, GBP, EUR, CAD, JPY or INR.

maxItems caps the saved rows across all your queries (20 by default). The Actor reads at most 7 result pages per query and stops earlier when a page is empty or has no next-page link.

Here is the script. Its input is the Actor's own starting example:

import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])

run_input = {
    "searchQueries": ["thinkpad"],
    "country": "US",
    "maxItems": 20,
    "sortBy": "relevance",
}

run = client.actor("reventadata/amazon-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    raise SystemExit(f"Run did not succeed (status: {run.status if run else 'unknown'})")

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["asin"], "|", item["price"], item["currency"], "|", item["rating"], "|", item["title"][:60])

💡 Tip: keywords work like Amazon's search box, but the Actor adds one check of its own: every word of your query must appear in the product title (case and accents ignored). On the captured "thinkpad" page, 20 of the 22 results passed. The two that did not were a "Lenovo 15.6 FHD Essential Laptop" and a sponsored MacBook.

Step 3: Add sort order and filters

sortBy goes to Amazon in the search URL: relevance, price_low_to_high, price_high_to_low, review_rank or newest. Because country and sortBy are fixed lists in the input schema, a misspelled value is refused before the run starts.

The other filters run inside the Actor, after each page is read:

minPrice / maxPrice: a price band in the marketplace currency. When either is set, rows without a price are dropped.
minRating: a whole number from 1 to 5. Unrated products are dropped when it is set.
primeOnly: keeps rows where isPrime is true (see the next section for what that flag means).
excludeSponsored: drops results Amazon labels as sponsored.

On the captured page, the 20 rows that passed the keyword check included 5 sponsored ones and 2 without a rating. So excludeSponsored: true would keep 15 of them, and minRating: 4 would keep 18.

Note: filtered rows are never saved, and maxItems counts only saved rows.

Step 4: Run the Actor

Save the script as amazon_search.py and run it with python amazon_search.py. .call() starts the run on Apify and waits for it to finish; the script then checks the status and prints each row.

Behind the scenes, the Actor builds Amazon's search URL for your keyword, marketplace, page and sort order, reads the result cards, applies your filters, and saves the rows that pass. It pauses one second between pages. A product that shows up under two of your keywords is saved once, matched by ASIN.

For marketplaces outside the US and Canada, the Actor fetches pages through a web-unlocking service first. In our recon on 2026-10-17, amazon.de and amazon.es answered requests from US datacenter IPs with a captcha page.

⚠️ Tip: in Console, the run's tabs include its log, which is where to look first if something goes wrong.

Step 5: View and download results

Each row prints in your terminal. In Console, the rows sit in the run's Output tab, and Export downloads them. Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Here is a real row from the 2026-10-22 amazon.com capture, the third result on the page. I left out scrapedAt, the time the page was read:

{
  "asin": "B0HB8D3NQ3",
  "title": "Lenovo ThinkPad E16 Gen 3, 16GB DDR5 RAM, 512GB SSD, 500GB External HDD",
  "price": 1139.98,
  "currency": "USD",
  "listPrice": 1749.99,
  "discountPercentage": 35,
  "rating": 4.6,
  "reviewsCount": 343,
  "url": "https://www.amazon.com/dp/B0HB8D3NQ3",
  "image": "https://m.media-amazon.com/images/I/71GqQ5PQ+hL._AC_UY218_.jpg",
  "isPrime": true,
  "isSponsored": false,
  "country": "US"
}

And a trimmed row from an amazon.in capture of the same date (page 2 for "pressure cooker"):

{
  "asin": "B0843YY4QP",
  "price": 3292.0,
  "currency": "INR",
  "listPrice": 4140.0,
  "discountPercentage": 20,
  "rating": 4.3,
  "reviewsCount": 1687,
  "isPrime": false,
  "country": "IN"
}

Understanding your results

Every row has the same 14 fields:

asin: Amazon's 10-character product id, used to save each product once.
title: the product name, with the brand joined on when the card prints it separately ("Lenovo ThinkPad T16, ...", not "Lenovo").
price, currency: the current price as a number, in the marketplace currency.
listPrice: the crossed-out price, or null when the card shows none. On the captured page, 11 of 22 results had one. Check it is above price before you use it: on the amazon.in capture, 5 of 48 rows carried a per-unit price (such as "/100 ml") here instead, and their discountPercentage is null.
discountPercentage: computed by the Actor from price and listPrice, rounded; null unless the list price is higher. The captured page ran from 14 to 48 percent.
rating: stars out of 5, or null. Two captured rows had none.
reviewsCount: the exact count from Amazon's "N ratings" label; the India card above shows "(1.6K)", the row 1,687.
url: a clean https://www.<domain>/dp/<ASIN> link.
image: the thumbnail URL.
isPrime, isSponsored: flags read from the card.
country: the marketplace code.
scrapedAt: an ISO 8601 UTC timestamp.

Pro tips and advanced usage

Read isPrime as "labelled Prime on this visit". Logged-out pages no longer show a Prime badge; the Actor sets isPrime when the card shows Amazon's "Join Prime to get FREE delivery" line. On the captured amazon.com page, 8 of 22 results had it. The Actor's schema notes that amazon.in showed no Prime line on 2026-10-22, so India rows are false.
Check ratings next to review counts. Two captured ThinkPads had 5.0 stars, from 2 and 3 reviews. Sort on both columns, not one.
Batch keywords in one run. Put several phrases in searchQueries; rows are de-duplicated by ASIN across them, and maxItems caps the total.
Use Amazon's sort for depth. With at most 7 pages per query, price_low_to_high or review_rank changes which products you reach.
Skip the polling. Attach a webhook for the ACTOR.RUN.SUCCEEDED event. Its payload's resource is "the response of the Get Actor run API endpoint" (Apify docs), which carries defaultDatasetId.

Troubleshooting common issues

A run saved 0 rows (status message "0 results for ..."). A run that is blocked, cannot read a result page or finds a page without product cards ends FAILED. If the pages loaded with product cards but the filters rejected them all, it ends SUCCEEDED with an empty dataset. The log's summary line lists rejections by reason (keyword_mismatch, price_bounds, rating_threshold, prime_required, sponsored_excluded, duplicate), so you can see which filter removed everything.
primeOnly returns nothing. Likely on amazon.in, where no Prime line was seen; turn it off there.
Fewer rows than maxItems. The search ran out of pages (7 at most), or your filters dropped the rest. Each page logs how many cards it parsed and kept.
The run is refused at the start. A country or sortBy value outside the schema's list never starts a run; the caller gets an error instead.
Questions? Use the Actor's Store page.

Next steps

For current pricing and details, see the Store page.

To repeat a search, save your input as a task and add a schedule; Apify schedules use cron expressions. To push rows into other tools, Apify integrates with n8n, Make and Zapier.

What are you planning to track on Amazon? Drop a comment! 💬

How to Scrape AliExpress Search Results with Python

ReventaData — Mon, 02 Nov 2026 10:04:34 +0000

By the end of this tutorial, you will have a short Python script that turns AliExpress search results into structured JSON: one row per product with its id, title, canonical product URL, price, currency, star rating, units sold, image links and the shipping tag the card shows.

We use the Apify Actor AliExpress Scraper (reventadata/aliexpress-scraper). It is for anyone who tracks prices on AliExpress, sizes up a product niche by units sold, or compares listings by rating, and would rather read rows than scroll result cards.

⏱️ Time: setting this up takes a few minutes: an account, a token and one script.

You will learn how to configure the input, run the Actor from Python, read every field it returns, and avoid the filter traps that make a run come back empty.

Prerequisites

A free Apify account (sign up for free).
Your Apify API token, found at console.apify.com/settings/integrations.
Python 3.11 or newer, which apify-client requires.

Install the client:

pip install "apify-client~=3.0"

No scraping code is needed: the Actor fetches the search pages, reads the cards and saves the rows. You send an input and read the results.

What you'll achieve

You will send one or more search queries (for example phone case or mechanical keyboard) and receive one clean row per product card on the AliExpress search results. The Actor reads the search result cards only; it does not open product pages one by one.

That keeps each row to what a card shows: title, price, rating, the sold count, images and a shipping tag. There is no seller profile, description or variant table.

Example use case: you want the best-rated phone cases with real sales behind them. Set minRating to 4.5 and minSold to 100, and the Actor keeps only cards that clear both bars.

Step 1: Access AliExpress Scraper

Open the AliExpress Scraper page on Apify Store. In Apify Console, an Actor opens on its Input tab, where you can fill the same fields this tutorial sets from code.

We will run it from Python, so keep your API token at hand and export it:

export APIFY_API_TOKEN="<your token>"

Step 2: Configure your queries and the caps

The one required field is searchQueries: a list of search terms. For each query the Actor builds an AliExpress search URL and walks its pages. For the prefill query phone case, page 1 is:

https://www.aliexpress.com/w/wholesale-phone-case.html?page=1&SearchText=phone+case&shipTo=US&currency=USD

Here is the script. Its input is the Actor's own prefill: one query, 5 rows, one page.

import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])

run_input = {
    "searchQueries": ["phone case"],
    "maxItems": 5,
    "maxPages": 1,
    "country": "US",
    "currency": "USD",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
    },
}

run = client.actor("reventadata/aliexpress-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    raise SystemExit(f"Run did not succeed (status: {run.status if run else 'unknown'})")

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["id"], "|", item["title"][:60], "|", item["price"], item["currency"], "|", item["rating"], "|", item["soldCount"])

maxItems is the total number of rows to save across all queries. maxPages caps the pages walked per query. Without them, the defaults are 60 and 5.

Step 3: Add filters

Parameter	Type	Default	What it does
`country`	string	`US`	Sent to AliExpress as `shipTo`.
`currency`	string	`USD`	Sent to AliExpress as `currency`.
`minPrice`, `maxPrice`	number	none	Price band. A card with no readable price is dropped when either is set.
`minRating`	number	none	Minimum star rating, 0 to 5. Unrated cards are dropped when set.
`minSold`	integer	none	Minimum units sold. Cards without a sold count are dropped when set.
`proxyConfiguration`	object	Unblocker	Apify Unblocker proxy by default.

Three details worth knowing:

The filters run on the cards the Actor reads, after each page is fetched. A tight minSold can leave a page with few kept rows, so raise maxPages when you filter hard.
Every word of a query must appear in the title, ignoring case and accents. That is how the Actor drops the unrelated recommendation cards AliExpress shows when nothing matches a query.
Accessory and damaged listings are dropped. Titles with words like case, cover, cable, strap or holder are treated as accessories, unless your query itself contains case, cover, protector, cable, strap or tip. Titles admitting damage (broken, faulty, cracked, for parts, not working) are dropped too, but a negation such as "anti scratch" keeps the row.

Step 4: Run the Actor

Run the script with python aliexpress.py. .call() starts the Actor on Apify and waits until it finishes. Behind the scenes the Actor requests each search page (through Apify's Unblocker proxy, unless you change proxyConfiguration), reads the result cards, applies your filters and saves the rows. A product that shows up under two of your queries is saved once.

A query stops at the first page with no cards, or when you reach maxPages. Rows stop being saved at maxItems: the current query may still read its remaining pages, and later queries are skipped.

⚠️ Tip: .call() blocks until the run ends. To fire and forget, use a webhook instead (see the pro tips below).

Step 5: View and download results

The script prints one line per row. In Apify Console, results appear in the run's Output tab, and Export downloads them. Datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Here is a sample row, a sample from a capture dated 2026-10-16: one search card saved from the Spanish storefront in a browser and parsed with the Actor's own row builder. It is not output of the prefill input above, which is why the price is in euros. matchedKeyword and scrapedAt are left out:

{
  "id": "1005010497678198",
  "title": "Auriculares Inalámbricos Bluetooth 5.3 HiFi Estéreo Resistente al Sudor Cascos Calgante Deportivo TEISCHE SW-08",
  "url": "https://www.aliexpress.com/item/1005010497678198.html",
  "price": 7.71,
  "originalPrice": null,
  "discountPercent": null,
  "currency": "EUR",
  "rating": 4.9,
  "soldCount": 38,
  "soldText": "38 vendidos",
  "thumbnailUrl": "https://ae-pic-a1.aliexpress-media.com/kf/E8a248d80dbf340dfa7bb04ad6b8d07a0h.jpg_480x480q75.jpg_.avif",
  "galleryImages": [
    "https://ae-pic-a1.aliexpress-media.com/kf/E8a248d80dbf340dfa7bb04ad6b8d07a0h.jpg_480x480q75.jpg_.avif",
    "https://ae-pic-a1.aliexpress-media.com/kf/Eb36c445f517d42efa7b4f1b916048f2ef.jpg_480x480q75.jpg_.avif",
    "https://ae-pic-a1.aliexpress-media.com/kf/E95a75f15f62543ccbbd8d0aba4ee4293s.jpg_480x480q75.jpg_.avif",
    "https://ae-pic-a1.aliexpress-media.com/kf/E34099cc5d0ee42f59a3a636328810addc.jpg_480x480q75.jpg_.avif",
    "https://ae-pic-a1.aliexpress-media.com/kf/E8c10f199c77049a0a5cb4fa099b304efF.jpg_480x480q75.jpg_.avif"
  ],
  "shippingDisplay": "Envío gratis a partir de 10,9€",
  "isFreeShipping": false
}

Understanding your results

id is the AliExpress product id, and url is rebuilt from it as https://www.aliexpress.com/item/<id>.html, with the long query string of the card link dropped.
price is the price shown on the card, as a number. currency is read from the card when it shows a euro, pound or dollar sign or code, else it is the currency you asked for.
originalPrice and discountPercent are null in every row of the current version, so do not build a discount report on them yet.
soldCount is the digits of soldText: "38 vendidos" becomes 38, and a text like "1,000+ sold" becomes 1000, a floor rather than an exact count.
isFreeShipping is true only when the tag says plain "Free shipping" (or "Envío gratis"). A conditional tag, like the "free shipping from 10,9€" one above, stays in shippingDisplay and leaves the flag false.
galleryImages holds up to 5 image links from the card.
matchedKeyword is the query that kept the row; scrapedAt is when it was saved.

Pro tips and advanced usage

Write queries in the words of the titles. The sample card's title is Spanish, so wireless earbuds would not keep it, while auriculares inalambricos would: every query word must be in the title.
Use minSold to skip untested listings. Cards without a sold count are dropped when it is set, so you only get products with sales on display.
Put several queries in one run. searchQueries takes a list, and a product found by two of them is saved once.
Hook it to your pipeline. An Apify webhook fires when a run finishes; its resource is "the response of the Get Actor run API endpoint" (docs.apify.com/integrations/webhooks/actions), which carries defaultDatasetId.
Check currency in your own rows. The Actor sends country and currency to AliExpress, and it takes the row's currency from the card when the card shows one, so read it from the rows rather than assuming it.

For current pricing and details, see the Store page.

Troubleshooting common issues

"0 results for queries ...". A blocked page or a page without cards ends the run FAILED; when pages loaded but nothing passed, it ends SUCCEEDED with an empty dataset. Usually a query word is missing from the titles, or minRating, minSold or the price band dropped every card. Loosen one at a time.
Fewer rows than maxItems. The filters dropped cards and maxPages ran out first. Raise maxPages.
Nothing happens and the log says "No searchQueries provided in input." The query list is empty; add at least one query.
An input rejected at start. maxItems and maxPages must be at least 1, the price and sold filters 0 or more, and minRating between 0 and 5; an input outside the schema is refused before the run starts.

The run's log shows each page fetched and how many cards were parsed and kept on it.

Next steps

Save your input as an Apify task and add a schedule: schedules use cron expressions, so a daily price check is one line (docs.apify.com/actors/running/schedules). The Apify Python client docs cover the rest of the API. Start with the prefill input above and grow from there.

What are you planning to scrape on AliExpress? Drop a comment! 💬

How to Scrape Instagram Posts and Profile Stats with Python and Apify

ReventaData — Mon, 02 Nov 2026 10:03:44 +0000

By the end of this tutorial, you will have a short Python script that turns public Instagram usernames and post links into structured rows: caption, like and comment counts, image link and date for each post, plus follower, following and post counts for each profile.

We use two Apify Actors that share one input style: Instagram Posts & Engagement Scraper (reventadata/instagram-scraper) for posts, and Instagram Profile & Followers Scraper (reventadata/instagram-profile-scraper) for profile stats. Both read the public pages a logged-out browser sees and send no login.

The two sample rows below are a sample from a capture dated 2026-10-22 (a National Geographic post) and a sample from a capture dated 2026-10-17 (the @instagram profile), parsed with each Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run two short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will get two datasets from one script:

Posts: one row per post with id (the shortcode), url, caption, likesCount, commentsCount, imageUrl, author (the account's display name) and timestamp.
Profiles: one row per username with username, fullName, biography, followersCount, followingCount, postsCount, avatarUrl and url.

Note: Both Actors are unofficial and not affiliated with Instagram or Meta. They do not read comments, follower lists or private accounts.

Example use case: Suppose you track a handful of brand or creator accounts. The profile Actor gives you each account's follower and post counts in one row; the posts Actor gives you the captions and engagement of each account's newest posts. Join them on the username and you have a small engagement table you can refresh on a schedule.

Step 1: Access the two Actors

Go to the Instagram Posts & Engagement Scraper and the Instagram Profile & Followers Scraper pages on Apify Store. Each README lists every input and output field. In this tutorial we drive both Actors from Python, so everything after this step happens in code.

Step 2: Configure the inputs

Posts Actor. It takes two kinds of target, and you can mix them:

directUrls: post or reel links such as https://www.instagram.com/p/DeuOR-CjKE9/. A link without /p/ or /reel/ is read as a profile page.
usernames: public usernames such as natgeo (a leading @ is stripped). For each one the Actor opens the profile page and saves the newest posts it lists. Per the README, that was 12 per profile when checked on 2026-10-22; older posts are not reached.

Profile Actor. It takes usernames only. A handle, an @handle or a full profile URL all work: @natgeo and https://www.instagram.com/natgeo/ both become natgeo.

Both Actors have maxItems (1 to 5,000, default 20), which caps the rows saved in the run. A value outside that range is refused before the run starts.

Here is the setup. It defines one helper that runs an Actor and returns its rows:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Run an Actor, wait for it, and return its dataset rows
def run_actor(actor_id, run_input):
    run = client.actor(actor_id).call(run_input=run_input)
    if run is None or run.status != "SUCCEEDED":
        status = run.status if run else "unknown"
        raise SystemExit(f"{actor_id} did not succeed (status: {status}).")
    return client.dataset(run.default_dataset_id).list_items().items

💡 Tip: start with maxItems: 5, the value both input forms prefill, until your downstream code handles the fields.

Step 3: Add the optional filter and proxy

The profile Actor has one filter: minFollowers. Profiles below it are dropped before they are saved, and so is a profile whose follower count could not be read.

Both Actors take proxyConfiguration. Leave it out: when none is given, they fetch through Apify Unblocker (proxy group UNBLOCKER).

Parameter	Actor	What it does
`directUrls`	posts	Post, reel or profile links.
`usernames`	both	Profiles to read (posts: newest listed posts; profiles: one row each).
`maxItems`	both	Rows saved at most, 1 to 5,000.
`minFollowers`	profiles	Drop profiles with fewer followers.
`proxyConfiguration`	both	Apify proxy settings; Unblocker when unset.

Step 4: Run the Actors

Now call the helper once per Actor. Each call() starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Newest posts of one profile, at most 5 rows
posts = run_actor(
    "reventadata/instagram-scraper",
    {"usernames": ["natgeo"], "maxItems": 5},
)

# 4. Profile stats, one row per username
profiles = run_actor(
    "reventadata/instagram-profile-scraper",
    {"usernames": ["instagram", "natgeo"], "maxItems": 5},
)

for p in profiles:
    print(f"@{p['username']}: {p['followersCount']} followers, {p['postsCount']} posts")
for post in posts:
    print(f"{post['timestamp']} | {post['likesCount']} likes | {post['url']}")

Behind the scenes:

For a username, the posts Actor reads the profile page, takes the post codes it lists, then opens each post page and reads its caption, counts and image.
A post or profile already saved in the run is not saved twice.
Each Actor stops at maxItems or when it runs out of targets.

Step 5: View and download results

Here is one post row, a sample from a capture dated 2026-10-22, parsed with the posts Actor's own parser (image link shortened). A saved row also carries scrapedAt, added at save time:

{
    "id": "DeuOR-CjKE9",
    "url": "https://www.instagram.com/p/DeuOR-CjKE9/",
    "caption": "Some of the best reasons to travel in 2027 are far from the usual destinations. 🌎\n\nNational Geographic’s picks for Best of the World 2027 are here and features 25 destinations across six continents. \n\nWhether you're drawn to places steeped in history or the thrill of exploring the wild, there's no shortage of experiences worth planning a trip around. \n\nFind your next adventure and see our full #BestOfTheWorld 2027 guide at the link in bio. \n\nPhotograph by Thomas Ekström",
    "likesCount": 12000,
    "commentsCount": 147,
    "imageUrl": "https://scontent.cdninstagram.com/v/t51.82787-15/858921974_18710195065019133_277441153414192961_n.jpg?stp=c216.0.648.648a_dst-jpg_e35_s640x640_tt6&...",
    "author": "National Geographic",
    "timestamp": "October 20, 2026"
}

And one profile row, a sample from a capture dated 2026-10-17, parsed with the profile Actor's own parser (the avatar link is a stand-in from the test capture):

{
    "id": "instagram",
    "username": "instagram",
    "fullName": "Instagram",
    "biography": "Discover what's new on Instagram 🔎✨",
    "followersCount": 687000000,
    "followingCount": 308,
    "postsCount": 8620,
    "avatarUrl": "https://scontent.cdninstagram.com/v/avatar.jpg",
    "url": "https://www.instagram.com/instagram/"
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

likesCount, commentsCount: integers, rounded the way Instagram shows them. The captured post's page said 12K likes, 147 comments, so the row holds 12000 and 147. Treat values in the thousands as approximate.
followersCount, followingCount, postsCount: same rule. 687M followers became 687000000; 8,620 posts became 8620.
timestamp: the post date as Instagram writes it (October 20, 2026), not an ISO timestamp. Parse it yourself if you need a date type.
author: the display name (National Geographic), not the handle. The handle is the username you passed in.
caption: the full caption, line breaks kept as \n.
imageUrl, avatarUrl: Instagram CDN links. They expire, so download the image soon if you need it.
url: posts always come back as /p/<shortcode>/, reels included; profiles as https://www.instagram.com/<username>/.
fullName: falls back to the username when the page shows no name, so a name equal to the handle may mean no name was shown.

Pro tips

Mix links and usernames in one posts run. Put specific post links in directUrls and accounts in usernames; duplicates are saved once.
Use the profile Actor as a pre-filter. Run it with minFollowers on a long list of candidates, then pass only the usernames that came back to the posts Actor.
Expect the newest posts only. A username yields the posts its profile page lists, not the full history. For an older post, pass its link in directUrls.
Normalise the date column. timestamp is text such as October 20, 2026; convert it with datetime.strptime(value, "%B %d, %Y") before sorting.
Read rows with iterate_items() for big runs. list_items() makes one API call; iterate_items() pages through every row.
Give each integration its own token. Apify's API docs advise a token with a clear description per service, never one token shared across several, the same way you would not reuse one password for different accounts.

Troubleshooting

Run FAILED with zero rows: both Actors fail a run when a page is blocked or cannot be read (a typo in a username, a login wall), and the posts Actor also fails when no input is given (the profiles Actor ends SUCCEEDED with no rows); an over-strict minFollowers on profiles that loaded ends SUCCEEDED with an empty dataset and a status message saying so.
Fewer posts than maxItems: a username yields only the posts its profile page lists. A profile page with no post list is skipped with a warning in the log.
Check the log: a summary line near the end reads Run finished: pushed N records to dataset. From Python: client.log(run.id).get(), with run from call().

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To refresh the table, save each input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which accounts are you planning to track? Drop a comment! 💬

How to Scrape Freshmile EV Charging Stations and Tariffs with Python

ReventaData — Mon, 02 Nov 2026 08:58:58 +0000

By the end of this tutorial, you will have a short Python script that turns a map box into structured rows of EV charging stations on the Freshmile network: name, address, coordinates, live availability, connector types, power in kW and each connector's tariff as Freshmile publishes it.

There is no HTML to parse. The Actor reads Freshmile's public JSON map API, which answered with no key, token or login when it was measured on 2026-09-22, and calls it directly, with no proxy by default.

In this guide, we use Python and the Apify Actor Freshmile Scraper (reventadata/freshmile-scraper). You will set a search box, run the Actor and read the rows. The sample row below is a sample from a capture dated 2026-09-22, parsed with the Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn a bounding box (four map edges in decimal degrees) into one row per charging station. Each row carries the station id (Freshmile's station ref) and locationId, name, address, city, postalCode, country, latitude and longitude, the isAvailable flag, evseCount (EVSEs, the charging points), connectorCount, maxPowerKw, and a connectors list with each connector's power, standard and tariff.

Note: The Actor reads station data only. Its rows carry no user fields and no map preview image link (the site's preview link embeds a third-party key, so it is left out).

Example use case: Suppose you want every Freshmile station around one Paris street with its connector mix and tariff text, to compare charging prices. You draw a tight box around the street, keep fetchDetails on, and each saved row carries its connectors with the tariff wording Freshmile shows.

Step 1: Access Freshmile Scraper

Go to the Freshmile Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the search box

The main input is the box: bboxWest, bboxSouth, bboxEast and bboxNorth, in WGS84 decimal degrees (the longitude and latitude any web map shows). All four are required. West must be smaller than east, and south smaller than north.

Two caps control the size of the run:

zoom: the zoom hint sent with the box (0 to 22, default 18).
maxItems: the most stations the run processes (default 100).

Here is the setup. It searches a small box in central Paris, the same box the Actor's input form is prefilled with, and processes at most 10 stations:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the search box (Paris, around Rue Pierre Charron) and the caps
run_input = {
    "bboxWest": 2.303,
    "bboxSouth": 48.869,
    "bboxEast": 2.3045,
    "bboxNorth": 48.8705,
    "zoom": 18,
    "maxItems": 10,
    "fetchDetails": True,
}

💡 Tip: keep the box tight. Freshmile groups stations into clusters by box size and density, not by zoom alone: on 2026-09-22 a tight Paris box at zoom 15 or 18 returned single stations, while a wide box over the same area (2.0,48.5,2.7,49.0) at zoom 20 returned 11 clusters and no single station.

Step 3: Choose how much detail you need

fetchDetails (default true) decides what each row holds:

`fetchDetails`	What the Actor does	What you get
`true`	Calls each station's detail endpoint	Name, address, EVSEs, every connector with power, standard and tariff
`false`	Keeps the search result only	`id`, `locationId`, coordinates, `isAvailable`, `isOpen`, `evseCount`; name, address and connectors stay empty

Turn it off when you only need positions and availability: the run skips one detail request per station.

proxyConfiguration is optional and off by default. The input form says it plainly: the API answers direct calls; enable a proxy only if direct calls are refused.

⚠️ A box edge outside the valid range (longitude -180 to 180, latitude -90 to 90) or a missing edge is refused before the run starts. A box with west not smaller than east, or south not smaller than north, stops the run with an error at its start.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/freshmile-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting Freshmile extraction...")
run = client.actor("reventadata/freshmile-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved stations
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} stations.\n")

Behind the scenes:

The Actor sends your box to Freshmile's map search, which answers with single stations and clusters.
When clusters come back, it splits the box into four quarters and searches each, up to three levels deep, and stops splitting once it has enough stations.
With fetchDetails on, it requests each station's detail, turns it into a row and saves it.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    print(item["name"] or item["id"])
    print(f"  City: {item.get('city')}  Available: {item.get('isAvailable')}")
    print(f"  Max power: {item.get('maxPowerKw')} kW, connectors: {item.get('connectorCount')}")
    tariffs = {c["tariffDescription"] for c in item["connectors"] if c.get("tariffDescription")}
    for text in tariffs:
        print(f"  Tariff: {text.splitlines()[0]}")
    print("-" * 40)

Here is one row, a sample from a capture dated 2026-09-22 (a station inside the box above), parsed with the Actor's own parser. connectors is cut to the first 2 of its 8 entries, and scrapedAt, the run's timestamp, is left out:

{
  "id": "FRV75PX08014",
  "locationId": 172076,
  "name": "Paris | Rue Pierre Charron  62",
  "address": "62 Rue Pierre Charron",
  "city": "Paris",
  "postalCode": "75008",
  "country": "FRA",
  "latitude": 48.869644,
  "longitude": 2.30362,
  "isAvailable": true,
  "isOpen": false,
  "twentyfourseven": false,
  "regularHours": [],
  "evseCount": 4,
  "connectorCount": 8,
  "maxPowerKw": 7.0,
  "connectors": [
    {
      "powerKw": 2.0,
      "standard": "DOMESTIC_F",
      "isAttached": true,
      "tariffName": "Interop sortante - Normal temps (20)",
      "tariffCurrency": "EUR",
      "tariffDescription": "€ 0.25 / started kWh + € 0.07 / min.\r\nThe pricing continues as long as the vehicle remains plugged in."
    },
    {
      "powerKw": 7.0,
      "standard": "IEC_62196_T2",
      "isAttached": false,
      "tariffName": "Interop sortante - Normal temps (20)",
      "tariffCurrency": "EUR",
      "tariffDescription": "€ 0.25 / started kWh + € 0.07 / min.\r\nThe pricing continues as long as the vehicle remains plugged in."
    }
  ]
}

For that row, the loop prints the station name, City: Paris Available: True, Max power: 7.0 kW, connectors: 8 and one tariff line.

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

id and locationId: Freshmile's station ref, stable per station, and the numeric id its detail endpoint uses.
isAvailable: at least one charge point is available at read time. In the capture, all 4 of the station's charge points showed AVAILABLE.
evseCount, connectorCount, maxPowerKw: charge points, connectors across them, and the highest connector power. The captured station had 4 charge points with 2 connectors each: a 2 kW DOMESTIC_F and a 7 kW IEC_62196_T2.
connectors[].tariffDescription: the tariff text exactly as Freshmile publishes it, not split into numbers. All 8 captured connectors carried the same tariff, in EUR.
isOpen and twentyfourseven: flags as Freshmile reports them. In the 2026-09-22 captures, the same station read isOpen: true in the map search and false in its detail, so check both before relying on it. twentyfourseven: false with empty regularHours means no hours were published, not that the station is closed.
scrapedAt: one timestamp per run, taken when the station search finishes.

Pro tips

Many tight boxes beat one wide box. Clusters are split at most three levels deep; stations still clustered after that are not returned. For a whole city, run several small boxes, one task each.
Skip details for a quick map. fetchDetails: false returns positions, isAvailable and evseCount without a detail request per station.
Use maxItems as a budget. It caps the stations processed, search hits and detail requests alike. Keep it at 10 while you test your code, then raise it.
Compare tariffs by text. Group rows by tariffName or tariffDescription to see which stations share a price plan.
Leave the proxy off. The Actor calls the API directly by default; turn on proxyConfiguration only if the log shows refused requests.
Track availability over time. Schedule the same box and join runs on id, Freshmile's stable station ref; each run's scrapedAt tells you when its isAvailable values were read.

Troubleshooting

Zero rows: a run where the box search was refused or every station's detail request failed ends FAILED; a box that loads normally but holds no Freshmile station ends SUCCEEDED with an empty dataset and a status message saying so.
Run stops at once: check the box edges; west must be smaller than east, south smaller than north.
Fewer rows than expected: read the summary line near the end of the log, Run completed. Pushed N rows. Rejected: {...}; it counts stations skipped by reason, such as a failed detail request. From Python: client.log(run.id).get().
Wide box, few stations: split the box (Pro tip 1).

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To refresh availability on a timetable, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which charging areas are you planning to map? Drop a comment! 💬

How to Scrape Cash Converters Spain Prices and Grades with Python

ReventaData — Mon, 02 Nov 2026 08:58:40 +0000

By the end of this tutorial, you will have a short Python script that turns a Cash Converters Spain search into structured rows: title, asking price in euros, the shop's own condition grade, the discount badge, the price when new, the saving against new, and the store that holds each unit.

Cash Converters is a second-hand shop chain, not a marketplace: it grades its own stock as Perfecto, Bueno or Usado and writes its own titles. That makes its catalogue a clean reference for second-hand prices.

In this guide, we use Python and the Apify Actor Cash Converters Spain Scraper (reventadata/cashconverters-scraper). The sample row shown below is a sample from a capture dated 2026-08-24 (the day it was added to the Actor's test suite), parsed with the Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn a Cash Converters Spain search into one row per physical unit, not per model. Each row carries title, price and currency (EUR), condition (the shop's grade), discountPercent, priceWhenNew, savingVsNew, brand, category, productId, storeId, a url that opens this exact unit, and imageUrl.

Note: The same model can appear several times, once per branch that holds a unit. Those are different phones in different stores, not duplicates.

Example use case: Suppose you want the resale price of an iPhone 13 mini 128 GB in good condition or better. You would set searchQueries: ["iphone 13 mini"], conditions: ["a", "b"] and minStorageGb: 128, and every saved row would be a Perfecto or Bueno unit whose title states at least 128 GB.

Step 1: Access Cash Converters Spain Scraper

Go to the Cash Converters Spain Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the search

The main input is searchQueries: one Cash Converters search per term, such as iphone 13 mini or macbook pro. There is no default; a run with no non-empty keyword fails with a Bad input message instead of searching for something you did not ask for.

maxItems caps the rows saved across the whole run (default 1000). Each keyword is paged until the results end, 100 items per request, up to 40 pages.

Here is the setup. It searches iphone 13 mini and saves at most 10 rows:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the search: one keyword, at most 10 rows
run_input = {
    "searchQueries": ["iphone 13 mini"],
    "maxItems": 10,
}

💡 Tip: the site's own search is fuzzy: iphone 13 mini also returns iPhone 13 and iPhone 13 Pro. requireKeywordMatch (on by default) drops any item whose title does not contain every word of your query, ignoring case and accents.

No proxy setting is needed in run_input. The README notes the catalogue answers plain HTTP; the input defaults to Apify Proxy, and "proxyConfiguration": {"useApifyProxy": false} fetches directly.

Step 3: Add optional filters

Some inputs are sent to Cash Converters with the search, so the site itself narrows what it returns. Others run on the rows the Actor reads:

Parameter	Type	Where it applies
`conditions`	array	Sent to the site: `a` Perfecto, `b` Bueno, `c` Usado. Empty means any grade. One pass per grade.
`minPrice` / `maxPrice`	integer	Sent to the site, in euros. Left out of the request when empty.
`sortBy`	string	Sent to the site: `price-low-to-high`, `price-high-to-low`, `Novedad Tienda Desde` (newest in store) or `Oferta` (on offer). Order only.
`minStorageGb`	integer	Row filter on the capacity in the title. 1TB counts as 1024. Titles with no capacity are dropped when set.
`minDiscountPercent`	integer	Row filter on the discount badge (0 to 99). Rows with no badge are dropped when set.
`requireKeywordMatch`	boolean	Row filter: every query word in the title. Default on.
`fetchDetails`	boolean	Not a filter: opens each product page for battery health, stock and rating.

Three combinations that work:

Cheapest good units first: conditions: ["a", "b"], sortBy: "price-low-to-high".
Big discounts only: minDiscountPercent: 40.
Price band: minPrice: 150, maxPrice: 400.

⚠️ conditions accepts only a, b and c. Any other value is refused before the run starts, which matters here because Cash Converters answers an unknown grade with an empty result, not an error.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/cashconverters-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting Cash Converters extraction...")
run = client.actor("reventadata/cashconverters-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved rows
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} items.\n")

Behind the scenes:

The Actor calls the same grid endpoint the site's own "load more" button uses, once per keyword and grade.
It reads each product tile's data-layer attribute (id, name, brand, category, price, grade), applies your filters and saves the rows.
It stops at maxItems, at the end of the results, or at the 40-page cap, which it reports in the log when it bites.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    print(f"{item['title']} ({item.get('condition')})")
    print(f"  Price: {item['price']} EUR")
    if item.get("priceWhenNew") is not None:
        print(f"  New: {item['priceWhenNew']} EUR, saving {item['savingVsNew']} EUR")
    print(f"  Store: {item.get('storeId')}")
    print(f"  Link: {item.get('url')}")
    print("-" * 40)

Here is one row, a sample from a capture dated 2026-08-24 (the day it was added to the Actor's test suite), parsed with the Actor's own to_row for the keyword iphone 13 mini. Prices and stock may have changed since:

{
    "batteryHealth": null,
    "batteryHealthMin": null,
    "inStock": null,
    "ratingValue": null,
    "title": "apple iphone 13 mini 128gb",
    "price": 283.95,
    "currency": "EUR",
    "condition": "Usado",
    "discountPercent": 35,
    "priceWhenNew": 439.99,
    "savingVsNew": 156.04,
    "brand": "apple",
    "category": "teléfonos/móviles/apple/iphone 13 mini 128gb",
    "productId": "CC007_E1032776_0",
    "storeId": "CC007",
    "url": "https://www.cashconverters.es/es/es/comprar/telefonos/moviles/apple/iphone-13-mini-128gb/?firstProduct=CC007_E1032776_0",
    "imageUrl": "https://images.cashconverters.es/productslive/smartphone/apple-iphone-13-mini-128gb_CC007_E1032776-0_0.jpg?d=small",
    "matchedKeyword": "iphone 13 mini"
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

price and currency: the asking price in euros, excluding delivery.
condition: the shop's own grade, Perfecto, Bueno or Usado. On a discounted tile the visible text reads Nuevo 439,99 €, where Nuevo labels the new price, not the grade; the Actor reads the grade from the tile's data attribute, so the sample row says Usado.
priceWhenNew: the struck-through figure, what the item costs new, not a former asking price. savingVsNew is priceWhenNew minus price: 439.99 minus 283.95 gives 156.04 in the sample.
discountPercent: the badge the site shows against the new price, 35 in the sample.
storeId: the branch holding the unit, from the id prefix. CC codes are Spanish stores, PT codes Portuguese stores selling through the same catalogue.
url: keeps ?firstProduct=<id>, so it opens this unit, not just the model page.
batteryHealth, batteryHealthMin, inStock, ratingValue: null unless fetchDetails is on.

Pro tips

Narrow on the site first. conditions, minPrice and maxPrice change what Cash Converters returns; minStorageGb and minDiscountPercent only drop rows after reading. A narrow row filter on a broad search reads many pages for few rows.
Read battery health with its floor. With fetchDetails, batteryHealth is a figure for this unit and batteryHealthMin is the warranty floor, usually 80. In the description "batería al 100% y una vida útil superior al 80%", the 100% is the charge level; the Actor's parser returns no health figure and a floor of 80 for it.
Batch keywords in one run. Put several terms in searchQueries. A unit saved under one term is not saved again under the next, and a unit rejected under one term can still match a later one.
Mind the grade passes. Each grade in conditions is its own pass over the results; leave it empty for any grade in one pass.
Start small. Keep maxItems: 10 until your downstream code handles the fields, then raise it.

Troubleshooting

Run failed with "Bad input": searchQueries had no non-empty keyword, or minPrice / maxPrice was not a finite number.
Input refused before the run starts: a conditions value other than a, b or c, or a sortBy value outside the list.
Run succeeded with zero rows: the status message starts 0 results for keywords ..., says the pages loaded normally but nothing matched, and lists the rejections. Widen the price range, drop minStorageGb or minDiscountPercent, or turn off requireKeywordMatch.
Run failed with "Every feed failed": no feed returned product tiles, for example a keyword the site has no results for. Check the keyword on the site.
Fewer rows than expected: read the log's Done. N item(s) considered, N pushed. line, and look for Stopped at the 40-page cap for: ...; narrow the keyword or set a price range to see the rest. From Python: client.log(run.id).get().

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

Which models are you planning to track on Cash Converters? Drop a comment! 💬

How to Audit Web Pages for WCAG Violations with axe-core and Python

ReventaData — Mon, 02 Nov 2026 08:58:21 +0000

By the end of this tutorial, you will have a short Python script that audits a list of web pages with axe-core and returns one row per failing element: the rule it broke, how serious it is, its CSS selector, its HTML and the advice for fixing it.

axe-core is Deque's open-source accessibility testing engine. Running it yourself means driving a real browser, injecting the script, and flattening its nested results into rows.

In this guide, we use Python and the Apify Actor axe-core Accessibility Audit Scraper (reventadata/axe-scraper). It is unofficial: it bundles axe-core 4.10.2 (MPL-2.0) and is not affiliated with Deque Systems. You will configure an audit, run it and read the rows. The sample row below is a sample from a capture dated 2026-10-12, parsed with the Actor's own code.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn a list of URLs into an accessibility report with one row per violating element. Each row carries url, ruleId (for example image-alt or color-contrast), impact (minor, moderate, serious or critical), help, description, helpUrl (a Deque University page for the rule), tags, target (CSS selectors), html (the element's markup) and failureSummary.

Note: Automated checks are a first pass, not a verdict. axe-core's own README says it finds "on average 57% of WCAG issues automatically". This Actor exports axe's violations only; the items axe marks "incomplete" (needs manual review) are not in the dataset.

Example use case: Suppose you want every critical and serious issue on your sign-up and checkout pages before a release. You would list both URLs in urls, set minImpact: "serious", and hand the rows to your issue tracker.

Step 1: Access axe-core Accessibility Audit Scraper

Go to the axe-core Accessibility Audit Scraper page on Apify Store. Its README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the pages and rules

The main input is urls: the pages to audit. Each must start with http:// or https:// and name a host; a URL that does not stops the run with an error at its start. Duplicates are removed, and pages are audited one after another in the order given.

wcagTags picks which axe rules run, by tag. It defaults to ["wcag2a", "wcag2aa"]. Per axe-core's API docs:

wcag2a, wcag2aa: WCAG 2.0 Level A and AA.
wcag21a, wcag21aa: WCAG 2.1 Level A and AA.
wcag22aa: WCAG 2.2 Level AA.
best-practice: common accessibility best practices.
section508: old Section 508 rules.

Here is the setup. It audits one page against WCAG 2.0 A and AA rules and saves at most 50 rows:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the audit: one page, WCAG 2.0 A and AA rules, at most 50 rows
run_input = {
    "urls": ["https://example.com"],
    "wcagTags": ["wcag2a", "wcag2aa"],
    "minImpact": "minor",
    "maxItems": 50,
}

This is the Actor's prefill input. Swap in your own pages.

💡 Tip: use the lowercase tags above. The Actor trims and lowercases every tag before passing it to axe.

Step 3: Add optional settings

Parameter	Type	What it does
`minImpact`	string	Keeps rows at or above this severity: `minor` (all, the default), `moderate`, `serious` or `critical`.
`maxItems`	integer	Caps the rows saved across all URLs (default 100).
`browserAuth`	string	Optional Bright Data Scraping Browser credentials, `brd-customer-ID-zone-NAME:PASSWORD`. A secret field.

Three configurations to try:

Release gate: minImpact: "serious" on your key templates.
WCAG 2.1 AA sweep: wcagTags: ["wcag2a", "wcag2aa", "wcag21a", "wcag21aa"].
Best-practice review: wcagTags: ["best-practice"], minImpact: "moderate".

⚠️ A minImpact outside the four values is refused before the run starts. browserAuth is a secret input: Apify's docs say such values get encrypted when the input is saved.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/axe-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting accessibility audit...")
run = client.actor("reventadata/axe-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved rows
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} rows.\n")

Behind the scenes:

The Actor opens a real Chromium browser: Bright Data's Scraping Browser over CDP when Scraping Browser credentials are available, otherwise a headless Chromium it launches itself.
For each URL it loads the page (45-second limit), waits one more second, injects axe-core 4.10.2 and runs it with your tags.
It turns each violation into one row per failing element, applies minImpact, and saves the rows until maxItems is reached.

Step 5: View and download results

Loop over the rows to print what you need:

from collections import Counter

for item in items:
    if item["ruleId"] == "wcag-pass":
        print(f"{item['url']}: no violations for the selected tags")
        continue
    print(f"[{item['impact']}] {item['ruleId']}: {item['help']}")
    print(f"  Element: {item['target']}")
    print(f"  Docs: {item['helpUrl']}")
    print("-" * 40)

print(Counter(item["impact"] for item in items if item["ruleId"] != "wcag-pass"))

Here is one row, a sample from a capture dated 2026-10-12 (an axe-core result for one image without alt text), parsed with the Actor's own code. The capture stores no page address, so url is the placeholder the Actor's tests pass. A saved row also carries scrapedAt, the audit time:

{
    "url": "https://example.com/test",
    "ruleId": "image-alt",
    "impact": "critical",
    "help": "Images must have alternative text",
    "description": "Ensure <img> elements have alternative text or a role of none or presentation",
    "helpUrl": "https://dequeuniversity.com/rules/axe/4.10/image-alt?application=axeAPI",
    "tags": [
        "cat.text-alternatives",
        "wcag2a",
        "wcag111",
        "section508",
        "section508.22.a",
        "TTv5",
        "TT7.a",
        "TT7.b",
        "EN-301-549",
        "EN-9.1.1.1",
        "ACT"
    ],
    "html": "<img src=\"broken.jpg\">",
    "target": [
        "img"
    ],
    "failureSummary": "Fix any of the following:\n  Element does not have an alt attribute\n  aria-label attribute does not exist or is empty\n  aria-labelledby attribute does not exist, references elements that do not exist or references elements that are empty\n  Element has no title attribute\n  Element's default semantics were not overridden with role=\"none\" or role=\"presentation\""
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

ruleId and help: the axe rule and its one-line title. helpUrl opens Deque's page for that rule.
impact: axe's severity for this element. When an element carries its own impact, the row uses it; otherwise the rule's.
target: CSS selectors for the element. Each entry is one frame level, so an element inside one iframe has two entries.
html: the element's markup, so you can find it in your templates.
failureSummary: what failed, phrased as a fix. "Fix any of the following" means one of the listed changes is enough.
tags: the standards the rule maps to. wcag111 is WCAG success criterion 1.1.1.

Two special rows: a page with no violations for your tags saves one row with ruleId: "wcag-pass" and impact: null. A rule axe reports without element details saves one row with html: null and an empty target.

Pro tips

Mind the shared cap. maxItems counts rows across all URLs, and once it is reached the remaining URLs are not audited. A page with many violations listed first can use the whole budget, so raise maxItems or audit busy pages in their own run.
Filter at the source. minImpact: "serious" keeps only serious and critical rows, which keeps a release check short.
Pick tags deliberately. The default covers WCAG 2.0 A and AA. Add wcag21a, wcag21aa or wcag22aa for the newer criteria; best-practice adds rules beyond WCAG.
Group before you fix. One rule often fails on many elements. Group rows by ruleId and fix the shared component once.
Plan manual review. The dataset holds axe's violations only; the "needs review" items stay for a person to check.
Make it a gate. The status check in Step 4 already stops on a failed run. Add one line that exits non-zero when any row has impact == "critical", and the audit can block a deploy.

Troubleshooting

Run stops at once: a URL lacks http:// or https://, or urls is empty.
Zero rows: the status message starts "0 results for ...". FAILED means no page loaded or audited, or at least one page could not be read, so matches may have been missed. SUCCEEDED with an empty dataset means the pages were audited but every row was below minImpact: lower it.
One page missing from the results: it failed to load and was skipped; the log has an Audit failed for <url> warning. Or maxItems was reached before its turn.
Reading the log: client.log(run.id).get(). It counts rows dropped by minImpact and near the end logs Pushed N item(s) across N attempted URL(s).

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To repeat an audit, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which pages are you planning to audit first? Drop a comment! 💬

How to Scrape EV Charging Stations and Live Plug Status with Python

ReventaData — Mon, 02 Nov 2026 08:58:02 +0000

By the end of this tutorial, you will have a short Python script that turns a rectangle on the map into one row per EV charging station: network, coordinates, top power in kW, each connector group, and how many connectors are available, charging or out of order.

The data comes from A Better Routeplanner (ABRP), an EV route planner whose web app loads chargers for the visible map area from its backend API. In this guide, we use Python and the Apify Actor ABRP EV Charging Scraper (reventadata/abrp-scraper), an unofficial tool not affiliated with ABRP or Iternio Planning AB. You will set a bounding box, run the Actor and filter by power and connector. The sample row below is a sample from a capture dated 2026-10-12, parsed with the Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn a map rectangle into one row per charging station. Each row carries the station id, networkName, latitude and longitude, an operational status, maxPowerKw, connector totals (totalConnectors, availableConnectors, chargingConnectors, outOfOrderConnectors), a connectors list with one entry per group, and a sourceUrl that opens the station on ABRP.

Note: ABRP reports power in watts; the Actor converts it to kW, rounded to one decimal.

Example use case: Suppose you want CCS chargers of at least 150 kW in one city. You would set the four box edges around the city, minPowerKw: 150 and connectors: ["CCS"], and every saved station would have at least one CCS group and a top power of 150 kW or more.

Step 1: Access ABRP EV Charging Scraper

Go to the ABRP EV Charging Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the bounding box

The main input is the box: four numbers in WGS84 decimal degrees, the format GPS and most map tools use.

bboxWest and bboxEast: the left and right longitudes (-180 to 180).
bboxSouth and bboxNorth: the bottom and top latitudes (-90 to 90).

All four are required. maxItems (default 100) caps the stations saved.

Here is the setup. It uses the input schema's prefill box, which contains the centre of Madrid (40.4169, -3.7033), and saves at most 10 stations:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the area: the input schema's prefill box, at most 10 stations
run_input = {
    "bboxWest": -3.75,
    "bboxSouth": 40.40,
    "bboxEast": -3.65,
    "bboxNorth": 40.45,
    "maxItems": 10,
}

💡 Tip: west must be smaller than east and south smaller than north, or the run stops with an error at its start. A box that crosses the 180th meridian therefore has to be split into two runs.

No proxy setting is needed: the proxy is off by default, and in recon on 2026-10-12 direct HTTPS calls reached ABRP's API host with no proxy, browser or challenge.

Step 3: Add optional filters

Two filters run on each station after the Actor reads it. Stations they drop never reach your dataset:

Parameter	Type	What it keeps
`minPowerKw`	integer	Stations whose fastest connector reaches N kW. 0 (the default) turns it off.
`connectors`	array	Stations with at least one of the listed standards: `CCS`, `TYPE2`, `CHADEMO`. Case does not matter; `Type 2` with a space does not match.
`apiKey`	secret string	Not a filter: your own Iternio API key. When it is left empty, the Actor uses the key ABRP's web client sends.

Three combinations that work as input:

Motorway-speed CCS: minPowerKw: 150, connectors: ["CCS"].
CHAdeMO drivers: connectors: ["CHADEMO"], no power floor.
Everything in a box: no filters, maxItems: 100.

⚠️ A coordinate outside its range, or a missing box edge, is refused before the run starts.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/abrp-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting ABRP charger extraction...")
run = client.actor("reventadata/abrp-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved stations
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} stations.\n")

Behind the scenes:

The Actor asks ABRP's bounding-box search for charger IDs inside your box, up to four times maxItems (at least 100).
It fetches the full station records in batches of 50, maps each to a row and applies your filters.
It stops once maxItems stations are saved or the IDs run out.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    print(f"{item.get('networkName') or 'unknown network'} ({item['id']})")
    print(f"  Max power: {item['maxPowerKw']} kW")
    print(f"  Free now: {item['availableConnectors']} of {item['totalConnectors']}")
    for c in item["connectors"]:
        print(f"    {c['standard']} {c['powerKw']} kW: {c['available']} of {c['count']} free")
    print(f"  Map: {item['sourceUrl']}")
    print("-" * 40)

Here is one row, a sample from a capture dated 2026-10-12 (one station record of the Eviny network, not from the Madrid box above) parsed with the Actor's own parser:

{
  "id": "1986998632",
  "name": "Eviny",
  "networkId": 12498,
  "networkName": "Eviny",
  "latitude": 55.717689514160156,
  "longitude": 13.165938377380371,
  "status": "OPEN",
  "hasDynamicStatus": true,
  "maxPowerKw": 350.0,
  "totalConnectors": 23,
  "availableConnectors": 18,
  "chargingConnectors": 2,
  "outOfOrderConnectors": 3,
  "connectors": [
    {
      "standard": "CCS",
      "powerKw": 350.0,
      "count": 10,
      "available": 7,
      "charging": 2,
      "outOfOrder": 1
    },
    {
      "standard": "CCS",
      "powerKw": 200.0,
      "count": 6,
      "available": 4,
      "charging": 0,
      "outOfOrder": 2
    },
    {
      "standard": "CHADEMO",
      "powerKw": 63.0,
      "count": 6,
      "available": 6,
      "charging": 0,
      "outOfOrder": 0
    },
    {
      "standard": "TYPE2",
      "powerKw": 22.0,
      "count": 1,
      "available": 1,
      "charging": 0,
      "outOfOrder": 0
    }
  ],
  "sourceUrl": "https://abetterrouteplanner.com/?charger_id=1986998632"
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

maxPowerKw: the highest power of any connector group. In the sample it is 350.0, from the first CCS group.
connectors: one entry per group, with standard, powerKw, count and the status split. The sample has four groups: CCS at 350 and at 200 kW, CHAdeMO at 63 kW and Type 2 at 22 kW.
availableConnectors, chargingConnectors, outOfOrderConnectors: totals across groups, as ABRP reported them when the record was fetched. In the sample, 18 of 23 were available, 2 charging and 3 out of order.
outOfOrder counts both statuses ABRP uses for a broken plug, OUTOFORDER and INOPERATIVE: the sample's 200 kW group had one of each, so it shows 2.
totalConnectors sums every group's count, so a status the Actor does not bucket still counts there.
hasDynamicStatus: whether live connector status is available for the station.
name currently holds the network name, the same value as networkName.

Pro tips

Draw a small box first. The prefill box covers a slice of one city. Start there, check the fields, then widen it.
Raise maxItems when you filter. The Actor requests four times maxItems candidate IDs (at least 100) and filters after fetching, so a strict filter can leave fewer than maxItems stations even when the area has more.
Know what minPowerKw tests. It compares the station's fastest connector. A 350 kW station passes minPowerKw: 150 and still lists its 22 kW group in connectors; filter the list yourself if you need only the fast plugs.
Use the standard names as written. CCS, TYPE2 and CHADEMO are the values in the sample; lowercase works, extra spaces do not.
Split big areas. Several smaller boxes, run as separate runs or scheduled tasks, keep each run inside its maxItems.
Automate from code. The same run_input works with .start() when you do not want to wait, and with a webhook that loads each finished dataset.

Troubleshooting

Run FAILED with zero rows: the Actor fails a run that saves nothing when it cannot confirm the box really was empty: the search returned no charger IDs, or a batch of station details came back empty. A box where stations loaded normally but every one failed your filters ends SUCCEEDED with an empty dataset and a status message listing the rejections.
Run stops at its start: bboxWest was not smaller than bboxEast, or bboxSouth not smaller than bboxNorth.
Input refused before the run starts: a box edge is missing or out of range.
Fewer stations than expected: read the log. Discovered N charger ID(s) across bounding box. gives the candidates; Sweep complete: N stations emitted, rejections: ... counts the filter drops. From Python: client.log(run.id).get().

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To watch one area, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which city or corridor are you planning to map chargers for? Drop a comment! 💬

How to Scrape Electromaps EV Charging Stations with Python

ReventaData — Mon, 02 Nov 2026 08:30:55 +0000

By the end of this tutorial, you will have a short Python script that turns a map rectangle into a list of EV charging stations from Electromaps: name, address, coordinates, connector mix, highest power in kW, community rating, opening hours and the price text the station publishes.

Electromaps is a charging-station map. It has no self-serve public API, so getting its stations into a spreadsheet by hand means clicking through the map one pin at a time.

In this guide, we use Python and the Apify Actor Electromaps EV Charging Scraper (reventadata/electromaps-scraper). You will draw a bounding box, add filters, run the Actor and read the rows. The sample row shown below is a sample from a capture dated 2026-09-22, parsed with the Actor's own code.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn a bounding box into one row per charging station. Each row carries the station id and url, name, address, city, postalCode, countryCode, latitude and longitude, the site type (locationType), rating and ratingCount, openTime, chargePrice, and a connectors list with each connector's type, status, power, voltage and amperage.

Note: statuses come back exactly as Electromaps reports them. Where a station's realtime flag is false, its statuses are crowdsourced, not live, and UNKNOWN stays UNKNOWN.

Example use case: Suppose you want every on-street or parking-lot charger of at least 50 kW inside a city. You would set the four box edges around the city, locationTypes: ["ON_STREET", "PARKING"] and minPowerKw: 50, and get one row per matching station with its connectors listed.

Step 1: Access Electromaps EV Charging Scraper

Go to the Electromaps EV Charging Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the bounding box

The four required inputs are the edges of the search box, in WGS84 decimal degrees (the latitude and longitude numbers any map shows):

bboxWest and bboxEast: the minimum and maximum longitude, between -180 and 180.
bboxSouth and bboxNorth: the minimum and maximum latitude, between -90 and 90.

West must be smaller than east and south smaller than north; otherwise the run stops with an error at its start. A value outside the ranges above is refused before the run starts.

Here is the setup. It uses the Actor's prefill box, a small rectangle in Vilanova i la Geltrú, Spain, with on-street and parking sites, detail on, at most 10 stations:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the search: one small box, two site types, at most 10 stations
run_input = {
    "bboxWest": 1.7227,
    "bboxSouth": 41.2135,
    "bboxEast": 1.724,
    "bboxNorth": 41.2145,
    "locationTypes": ["ON_STREET", "PARKING"],
    "maxItems": 10,
    "fetchDetails": True,
}

💡 Tip: on a web map that displays coordinates, read the four numbers off two opposite corners of the area you want. Start with a small box; you can widen it once the rows look right.

Step 3: Add optional filters

The first four are sent to Electromaps with the box, so stations that do not match never come back; the last two are the Actor's own settings:

Parameter	Type	What it does
`locationTypes`	array	Site types to keep. Omit it for all 12 the Actor knows.
`minPowerKw`	integer	Minimum connector power in kW. `0` turns it off.
`connectors`	array	Connector codes such as `IEC_62196_T2` or `CHADEMO`. Empty turns it off.
`realtimeOnly`	boolean	Only stations that report live data.
`maxItems`	integer	Cap on stations processed (default 100).
`fetchDetails`	boolean	Not a filter: one extra request per station for connectors, ratings and prices (default on).

The 12 site types the Actor accepts are ON_STREET, PARKING, AIRPORT, CAMPING, HOTEL, RESTAURANT, SHOP, WORKSHOP, FUEL_STATION, CAR_DEALER, MALL and TAXI. Lowercase is fine; the Actor upper-cases them.

Three combinations that work:

Fast chargers in a city: a city box, minPowerKw: 50.
Hotel chargers for a trip: a region box, locationTypes: ["HOTEL", "CAMPING"].
A quick pin map: any box, fetchDetails: false for id, name and coordinates only.

⚠️ A site type outside those 12 stops the run at its start, before any request is sent: Electromaps answers unknown types with HTTP 403.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/electromaps-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting Electromaps extraction...")
run = client.actor("reventadata/electromaps-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved stations
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} stations.\n")

Behind the scenes:

The Actor sends one request for the stations inside your box, with your filters, to the JSON that Electromaps' own map reads. No HTML is scraped, and no key or login is involved.
With fetchDetails on, it then requests each station's detail, up to maxItems stations, and turns it into one row.
A station whose detail fails is logged and skipped; the run carries on with the rest.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    print(item["name"], "|", item.get("city"))
    print(f"  Max power: {item.get('maxPowerKw')} kW, connectors: {item.get('connectorCount')}")
    print(f"  Status: {item.get('offlineStatus')} (realtime: {item.get('realtime')})")
    print(f"  Price: {item.get('chargePrice') or 'not published'}")
    for conn in item.get("connectors") or []:
        print(f"    {conn['type']} {conn['powerKw']} kW {conn['powerType']}: {conn['status']}")
    print("-" * 40)

Here is one row, a sample from a capture dated 2026-09-22 (the station inside the prefill box) parsed with the Actor's own code. A saved row also carries scrapedAt, the run's timestamp:

{
    "id": 307432,
    "name": "Ribes Roges 11 Vilanova i la Geltrú",
    "url": "https://map.electromaps.com/en/p/307432",
    "address": "Passeig de Ribes Roges, 10, 08800, Vilanova i la Geltrú",
    "city": "Vilanova i la Geltrú",
    "postalCode": "08800",
    "countryCode": "ES",
    "latitude": 41.213871159682,
    "longitude": 1.723192892969,
    "locationType": "ON_STREET",
    "rating": 3.1481,
    "ratingCount": 27,
    "onlineStatus": "UNKNOWN",
    "offlineStatus": "WORKING",
    "realtime": false,
    "openTime": "24h",
    "chargePrice": "Gratuito",
    "parkingPrice": "",
    "priceKwhFrom": null,
    "instructions": "App EVCharge",
    "contact": "Etecnic",
    "reservable": false,
    "onlyTesla": false,
    "connectorCount": 2,
    "maxPowerKw": 22.0,
    "connectors": [
        {
            "type": "IEC_62196_T2",
            "status": "UNKNOWN",
            "powerKw": 22.0,
            "powerType": "AC_3_PHASE",
            "voltage": 400,
            "amperage": 32,
            "format": "SOCKET"
        },
        {
            "type": "IEC_62196_T2",
            "status": "WORKING",
            "powerKw": 22.0,
            "powerType": "AC_3_PHASE",
            "voltage": 400,
            "amperage": 32,
            "format": "SOCKET"
        }
    ]
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

id and url: Electromaps' numeric station id and the station's page on its map (map.electromaps.com/en/p/<id>), handy as a join key between runs.
maxPowerKw and connectorCount: the highest connector power and the number of connectors. In the sample, two 22 kW connectors.
connectors: one object per connector. type is Electromaps' code (IEC_62196_T2 here), powerType is the current type (AC_3_PHASE here), plus voltage, amperage and format (SOCKET).
status, offlineStatus, onlineStatus, realtime: verbatim. The sample has realtime: false, so its statuses are crowdsourced; one connector reads WORKING and the other UNKNOWN, and the Actor guesses neither.
chargePrice and parkingPrice: text as the station publishes it. Gratuito is Spanish for free; the sample's parkingPrice is an empty string. priceKwhFrom is a number only when a per-kWh price is published.
rating and ratingCount: the community rating, 3.1481 from 27 ratings in the sample.
instructions and contact: access notes (App EVCharge) and the operator's name (Etecnic). Uploader usernames, avatars and ads are dropped.

Pro tips

Size the box to maxItems. A Barcelona-area box in the 2026-09-22 capture held 1,955 stations, and maxItems defaults to 100. Raise the cap or split a city into several boxes.
Filter on the server. locationTypes, minPowerKw, connectors and realtimeOnly are applied by Electromaps, so a narrow filter shrinks the list before any detail request.
Skip details for a pin map. fetchDetails: false saves id, name and coordinates only, with no extra request per station.
Treat statuses as reported, not live. Check realtime before you show a connector as available. For live-only data, set realtimeOnly: true.
Start small. Keep maxItems: 10 until your downstream code handles the fields, then raise it.
Connect it to the rest of your pipeline. A webhook on ACTOR.RUN.SUCCEEDED hands your endpoint the run object with its defaultDatasetId, so a script can load each new dataset as soon as a run ends. For bigger datasets, iterate_items() pages through the rows instead of loading them in one call.

Troubleshooting

Zero rows: a run that is blocked or cannot read a station's detail ends FAILED; an empty box or an over-strict filter ends SUCCEEDED with an empty dataset and a status message saying so. Widen the box or loosen minPowerKw.
Run stops at once: west is not smaller than east, south is not smaller than north, or a locationTypes value is not one of the 12.
Input refused before the run starts: a box edge outside -180 to 180 or -90 to 90, or a required edge missing.
Fewer rows than expected: read the summary line near the end of the log, Run completed. Pushed N rows. Rejected: {...}; it counts skipped stations by reason, such as a failed detail request. From Python: client.log(run.id).get().

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To refresh a box regularly, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which area are you planning to map? Drop a comment! 💬

How to Search Brazilian Company Records with CNPJ Brasil Scraper

ReventaData — Mon, 02 Nov 2026 08:30:37 +0000

By the end of this tutorial, you will have a short Python script that turns a company-name search into structured Brazilian company records: CNPJ, legal name (razão social), trade name (nome fantasia), registration status, primary CNAE activity, share capital, size tier and address.

Every Brazilian company has a CNPJ, the 14-digit national registry number. If you build B2B lead lists or check suppliers, you usually want those records filtered by state, status and activity, not looked up one by one.

In this guide, we use Python and the Apify Actor CNPJ Brasil Scraper (reventadata/cnpj-brasil-scraper). The sample rows below come from a local test run dated 2026-10-24, made with the input shown in the code. The Actor is unofficial and not affiliated with Casa dos Dados or Receita Federal.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install -U "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn a keyword search into one row per company. Each row carries cnpj and cnpjFormatted, legalName, tradeName (null when none is registered in the data), status, openingDate, cnaeCode and cnaeDescription, shareCapital in reais, legalNature, companySize, the isSimplesNacional, isMei and isMatriz flags, and the address split into city, state, neighborhood, street and zipCode.

Note: rows hold company fields only. The row has no partner list, CPF, phone or e-mail field, and the name search does not look at partner names.

Example use case: Suppose you want active software firms headquartered in Paraná. You would set searchQueries: ["software"], state: "PR", status: "ATIVA", cnaeCode: "6201501" and onlyMatriz: true, and every saved row would be an active company registered in PR whose name contains "software", found by a search limited to headquarters with that primary CNAE.

Step 1: Access CNPJ Brasil Scraper

Go to the CNPJ Brasil Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the search

The main input is searchQueries: one search per keyword, matched against the legal name and the trade name. A company is kept only if every word of the keyword appears in the two names taken together, ignoring case and accents, so seguranca eletronica also matches SEGURANÇA ELETRÔNICA.

Two inputs set the scope:

state: a two-letter code (SP, RJ, MG, PR, ...) or ALL for nationwide. Default SP.
status: ATIVA (active), BAIXADA (closed) or ALL. Default ATIVA.

maxItems (1 to 5,000, default 50) caps the rows saved across all keywords.

Here is the setup. It searches tecnologia among active companies in São Paulo state and saves at most 5 rows, the same input as the sample run:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the search: active companies in SP whose name contains "tecnologia"
run_input = {
    "searchQueries": ["tecnologia"],
    "state": "SP",
    "status": "ATIVA",
    "maxItems": 5,
}

💡 Tip: a keyword matches names, not activities. To find companies by what they do, combine a short keyword with cnaeCode (Step 3).

No proxy setting is needed: by default the Actor connects directly, and a direct connection returned real rows in the test run on 2026-10-24.

Step 3: Add optional filters

These inputs go into the search itself, and state, status and capital are checked again on each finished row:

Parameter	Type	What it keeps
`minCapital` / `maxCapital`	integer	Companies whose registered share capital in reais is inside the band. Rows without a capital figure are dropped when either is set.
`cnaeCode`	string	Companies whose primary activity is this 7-digit CNAE code, for example `6201501` (custom software development). Non-digits are stripped, so `6201-5/01` works too.
`onlyMatriz`	boolean	Headquarters only; branches (filiais) are left out.

Three combinations that work:

Established IT firms in Rio: searchQueries: ["tecnologia"], state: "RJ", minCapital: 100000.
Closed logistics companies nationwide: searchQueries: ["logistica"], state: "ALL", status: "BAIXADA".
Software headquarters in Minas Gerais: searchQueries: ["sistemas"], state: "MG", cnaeCode: "6201501", onlyMatriz: true.

⚠️ state and status only accept the listed values; anything else is refused before the run starts. Maranhão (MA) is not in the state list: use ALL and filter state in your own code.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/cnpj-brasil-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting CNPJ search...")
run = client.actor("reventadata/cnpj-brasil-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved company records
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} companies.\n")

Behind the scenes:

The Actor sends your keyword and filters to Casa dos Dados' public company search and reads the results in pages of 20.
For each match, it looks up the CNPJ's registry details on minhareceita.org: opening date, CNAE, capital, size, tax flags and address.
It drops companies already saved under an earlier keyword, applies the checks, and stops at maxItems or when the search runs dry.

Step 5: View and download results

Loop over the rows to print the parts you need:

for item in items:
    print(f"{item['cnpjFormatted']}  {item['legalName']}")
    print(f"  Trade name: {item.get('tradeName') or 'none'}")
    print(f"  CNAE: {item.get('cnaeCode')} {item.get('cnaeDescription')}")
    print(f"  City: {item.get('city')}/{item.get('state')}")
    print(f"  Share capital (BRL): {item.get('shareCapital')}")
    print("-" * 40)

Here is one row from the local test run dated 2026-10-24, exactly as the Actor saved it:

{
  "cnpj": "97552676000120",
  "cnpjFormatted": "97.552.676/0001-20",
  "legalName": "H&M TECNOLOGIA DA INFORMACAO LTDA",
  "tradeName": "MASSIMUS CONSULTING AND TRAINING",
  "status": "ATIVA",
  "openingDate": "2011-07-05",
  "cnaeCode": "8599603",
  "cnaeDescription": "Treinamento em informática",
  "shareCapital": 20000.0,
  "legalNature": "Sociedade Empresária Limitada",
  "companySize": "MICRO EMPRESA",
  "isSimplesNacional": true,
  "isMei": false,
  "isMatriz": true,
  "city": "Barueri",
  "state": "SP",
  "neighborhood": "Alphaville Centro Industrial E Empresarial/Alphav",
  "street": "Rio Negro, 503",
  "zipCode": "06454000",
  "matchedQuery": "tecnologia",
  "scrapedAt": "2026-10-24T18:07:59.445160+00:00"
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

cnpj / cnpjFormatted: the 14 digits, and the same number as XX.XXX.XXX/XXXX-XX.
legalName / tradeName: razão social and nome fantasia. In the five sample rows, 3 had no trade name (null).
status: ATIVA or BAIXADA; with status: "ALL" other registry statuses such as INAPTA or SUSPENSA can appear.
cnaeCode / cnaeDescription: the primary activity. The five sample rows had five different codes.
shareCapital: registered capital in reais, from 1,000 to 150,000 across the sample.
companySize: MEI, MICRO EMPRESA, EMPRESA DE PEQUENO PORTE or DEMAIS (other). DEMAIS is also what the Actor writes when the registry lookup gives no size.
isSimplesNacional, isMei: tax-regime flags. isMatriz: true for a headquarters, false for a branch.
openingDate: the registration start date as YYYY-MM-DD. All five sample rows opened in 2011.
city, neighborhood, street, zipCode: the registered address; street joins the street name and number, and was null in one sample row.
matchedQuery: which keyword produced the row.

Pro tips

Search names, filter activities. The keyword only looks at company names. One sample row had "TECNOLOGIA" in its name and an equipment-installation CNAE, so add cnaeCode when the activity matters.
Use short, distinctive keywords. Every word must appear in a name, so tecnologia sistemas keeps fewer companies than tecnologia.
Batch keywords in one run. Put several in searchQueries; a company saved under one keyword is not saved again under the next.
Bound by capital, not just count. minCapital and maxCapital are a quick proxy for company size when building lead lists.
Start small. Keep maxItems: 5 until your downstream code handles the fields, then raise it.
Automate the hand-off. A webhook on ACTOR.RUN.SUCCEEDED hands your code the finished run, so a scheduled search can land in a CRM or a sheet without polling. Key your table on cnpj: it identifies the company, so a rerun can update rows instead of duplicating them.

Troubleshooting

Zero rows: a run that is blocked or cannot read a search page ends FAILED. A search that loads normally but returns nothing your filters keep ends SUCCEEDED with an empty dataset and a status message saying so. Loosen the keyword, the state or the capital band.
Fewer rows than expected: read the summary line near the end of the log, Run finished. Total companies pushed: N. Rejection breakdown: {...}. It counts drops such as keyword_mismatch, state_mismatch and capital_out_of_range. From Python: client.log(run.id).get().
Fields are null: when the registry lookup for a CNPJ fails, the row keeps the search fields only (companySize falls back to DEMAIS); with a specific state, such rows are dropped.
Input refused: a state or status value outside the list.

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To repeat a search, save the input as a task and add an Apify schedule, which runs it on a cron expression (0 8 * * * is every day at 8 AM). To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which sectors or states are you planning to map? Drop a comment! 💬

How to Scrape Imovirtual Property Listings in Portugal with Python

ReventaData — Mon, 02 Nov 2026 08:30:18 +0000

By the end of this tutorial, you will have a short Python script that turns an Imovirtual search into structured rows: listing title, asking price in euros, price per m², area, rooms, floor, street, parish, council and district, the agency or developer behind the ad, and when it was listed.

Imovirtual (imovirtual.com) is a Portuguese real-estate portal for homes, land and commercial property, for sale or for rent.

In this guide, we use Python and the Apify Actor Imovirtual Scraper (reventadata/imovirtual-scraper). You will configure a search, run the Actor and read the rows. The sample row below is a sample from a capture dated 2026-10-20, parsed with the Actor's own parser.

⏱️ Time estimate: one sitting: install one package, set one token, run three short Python blocks.

Prerequisites

To follow this tutorial, you will need:

Python 3.11+ (apify-client 3.3.0 requires it).
The Apify API client for Python.
An Apify account and its API token, which sits on the API & Integrations page in Apify Console.

Install the client:

pip install "apify-client~=3.0"

The code reads the token from an environment variable:

export APIFY_API_TOKEN="your_apify_token_here"

What you'll achieve

You will turn one Imovirtual search into one row per listing. Each row carries the listing id and url, title, price with currency, pricePerSquareMeter, areaM2, rooms and roomsLabel, floor, the address levels (street, neighborhood, parish, council, district), agencyName and agencyType, isPrivateOwner, createdAt and pushedUpAt, and one imageUrl.

Note: A row carries no phone number or e-mail address. The ad url leads to the full listing page.

Example use case: Suppose you want two-bedroom flats for sale in Lisbon city under 400,000 EUR. You would set propertyType: "apartamento", location: "lisboa/lisboa", typology: "t2" and maxPrice: 400000, and Imovirtual itself applies the filters before a single row comes back.

Step 1: Access Imovirtual Scraper

Go to the Imovirtual Scraper page on Apify Store. The README lists every input and output field. In this tutorial we drive the Actor from Python, so everything after this step happens in code.

Step 2: Configure the search

Three inputs define the search:

transaction: buy or rent.
propertyType: apartamento (apartment), moradia (house), terreno (land), imoveis-comerciais (commercial), armazens (warehouse) or garagem (garage).
location: Imovirtual's own location slug, as it appears in a search URL: a district such as lisboa or porto, a council such as lisboa/lisboa or porto/porto, or todo-o-pais for the whole country.

To find a slug, search on imovirtual.com and copy the part of the URL after the property type: lisboa/lisboa from /pt/resultados/comprar/apartamento/lisboa/lisboa.

Each result page holds 36 listings. maxPages caps the pages read, and maxItems (default 1000) caps the rows saved.

Here is the setup. It searches apartments for sale in Lisboa district and reads one result page:

import os
from apify_client import ApifyClient

# 1. Initialize ApifyClient with the token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Define the search: apartments for sale in Lisboa district, one result page
run_input = {
    "transaction": "buy",
    "propertyType": "apartamento",
    "location": "lisboa",
    "maxPages": 1,
}

💡 Tip: lisboa is the whole district, not the city. In the capture, page 1 of this search spanned 8 councils, from Lisboa itself to Sintra, Loures and Vila Franca de Xira. Use lisboa/lisboa for the city.

No proxy setting is needed: the proxy is off by default, and plain requests with no proxy reached imovirtual.com when the Actor was tested on 2026-10-20.

Step 3: Narrow the search

These inputs go into the search URL, so Imovirtual filters before anything is fetched:

Parameter	Type	What it does
`typology`	string	`t0` to `t5`: the Portuguese bedroom count.
`minPrice` / `maxPrice`	integer	Price band in EUR.
`minArea` / `maxArea`	integer	Area band in m².
`ownerType`	string	`any`, or `private` for private owners only (no agencies or developers).
`sortBy`	string	`relevance` (the site's default), `priceAsc` (cheapest first) or `newest`.

An empty numeric filter is left out of the request, never sent as 0.

Three combinations that work:

Lisbon city T2 flats under 400,000 EUR: location: "lisboa/lisboa", typology: "t2", maxPrice: 400000.
Rentals in Porto, cheapest first: transaction: "rent", location: "porto/porto", sortBy: "priceAsc".
Houses sold by their owners, nationwide: propertyType: "moradia", location: "todo-o-pais", ownerType: "private", sortBy: "newest".

⚠️ A typology, sortBy, ownerType, transaction or propertyType outside its list is refused before the run starts. A location slug Imovirtual does not know stops the run with an error at its first page.

Step 4: Run the Actor

Now start the run with client.actor("reventadata/imovirtual-scraper").call(run_input=run_input). The call starts the Actor on Apify and waits for it to finish before returning the run:

# 3. Start the Actor run and wait for it to finish
print("Starting Imovirtual extraction...")
run = client.actor("reventadata/imovirtual-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Fetch the saved listings
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} listings.\n")

Behind the scenes:

The Actor builds the search URL (/pt/resultados/comprar/apartamento/lisboa here, plus ?page=N from page 2 on).
It reads the listing data Imovirtual embeds in its own search page, so no browser is involved, and turns each listing into one row.
It stops at maxItems, at maxPages, or at the last page the site reports, whichever comes first. The premium tile Imovirtual repeats across pages is saved once.

Step 5: View and download results

Loop over the rows to print the parts you need:

seen_urls = set()
for item in items:
    # Skip a second id that points to a listing already printed
    if item["url"] in seen_urls:
        continue
    seen_urls.add(item["url"])
    print(item["title"])
    price = item.get("price")
    print(f"  Price: {price:,.0f} EUR" if price is not None else "  Price: not published")
    print(f"  Per m2: {item.get('pricePerSquareMeter')} EUR, area {item.get('areaM2')} m2")
    print(f"  Rooms: {item.get('roomsLabel')}, floor {item.get('floor')}")
    print(f"  Where: {item.get('parish')}, {item.get('council')}")
    print(f"  Seller: {item.get('agencyName') or 'private owner'}")
    print("-" * 40)

Here is one row, a sample from a capture dated 2026-10-20 (page 1 of the search above) parsed with the Actor's own parser:

{
    "id": "19316271",
    "url": "https://www.imovirtual.com/pt/anuncio/apartamento-t3-a-venda-na-praca-das-novas-nacoes-arroios-ID1j32L",
    "title": "Apartamento T3 à venda na Praça das Novas Nações, Arroios",
    "propertyType": "FLAT",
    "transaction": "SELL",
    "price": 555000.0,
    "currency": "EUR",
    "pricePerSquareMeter": 6686.75,
    "priceFromPerSquareMeter": null,
    "areaM2": 83.0,
    "rooms": 4,
    "roomsLabel": "FOUR",
    "floor": "SECOND",
    "street": "Praça das Novas Nações",
    "neighborhood": "Anjos",
    "parish": "Arroios",
    "council": "Lisboa",
    "district": "Lisboa",
    "agencyName": "Century 21 CasaBela",
    "agencyType": "AGENCY",
    "advertiserName": "Century 21 CasaBela",
    "contactNames": [
        "Sofia Dias"
    ],
    "isPrivateOwner": false,
    "isPromoted": false,
    "isExclusiveOffer": false,
    "createdAt": "2026-10-20T18:14:18+00:00",
    "pushedUpAt": null,
    "imageUrl": "https://ireland.apollo.olxcdn.com/v1/files/eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmbiI6Ijd0a3lyMXJxdTdnYjMtRUNPU1lTVEVNIiwidyI6W3siZm4iOiI2OW5scGE3ZWNxbTcxLUFQVCIsInMiOiIxNiIsImEiOiIwIiwicCI6IjEwLC0xMCJ9XX0.YzJy2krk122zcGgyU5_lDEsJbUD59FTBaXjmIhte5Qk/image;s=1280x1024;q=80",
    "searchUrl": "https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa"
}

Apify datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL.

Understanding your results

The fields that matter most:

price, currency: the asking price in EUR, or the monthly rent on rent searches. Development listings publish no total price: price is null and priceFromPerSquareMeter holds the site's "from" price per m².
pricePerSquareMeter, areaM2: as the site publishes them. In the 37-row capture, prices ran from 355,000 to 9,000,000 EUR and price per m² from 1,446.95 to 6,875.
rooms, roomsLabel: rooms, not bedrooms. The sample's title says T3 and its roomsLabel is FOUR: three bedrooms plus the living room. Imovirtual's MORE has no number, so rooms is null there (4 rows in the capture).
floor: the site's value (GROUND, SECOND, ...); null on 10 of the 37 captured rows.
agencyType: AGENCY or DEVELOPER, null for a private owner (31, 5 and 1 in the capture).
createdAt, pushedUpAt: first listed and last bumped. 14 of the 37 captured rows were first listed on the capture day.
searchUrl: the page-1 search URL the row came from.

Pro tips

Deduplicate on url. The Actor removes repeated ids, but in the capture one listing also appeared under a second id (9000062240) with the same url, no image and a createdAt of 1999-02-29 00:00:01. The loop above keys on url for that reason.
Parse dates defensively. That same createdAt is not a real date. Wrap date parsing in a try/except instead of letting one row stop a pipeline.
Filter on the site, not in pandas. Price, area, typology and owner type go into the URL, so you read fewer pages for the same rows.
Use council slugs. lisboa/lisboa instead of lisboa keeps the suburbs out.
Keep sale and rent apart. On a rent search price is the monthly rent, so a sale and a rent dataset in one column mix two different numbers. Run them as separate searches.
Start small. Keep maxPages: 1 until your downstream code handles the fields, then raise it or leave it out to walk every page the site reports.

Troubleshooting

Zero rows: a run that is blocked, cannot read a page or gets a wrong slug ends FAILED; an over-strict filter ends SUCCEEDED with an empty dataset and a status message saying so. Widen the price or area band, or drop ownerType: "private".
Run stops at its first page with a 404 error: the location slug does not exist on Imovirtual. Copy it from a real imovirtual.com search URL.
Input refused before the run starts: a value outside a select list, such as typology: "t6".
Fewer rows than expected: read the run log. Near the end it logs Skipped N: ... lines and Pushed N row(s).. From Python: client.log(run.id).get().

For help, use the Actor's Store page.

Pricing and next steps

For current pricing and details, see the Store page.

To repeat a search, save the input as a task and add an Apify schedule, which runs an Actor or task on a cron expression (0 8 * * * is every day at 8 AM). Pair it with sortBy: "newest". To react when a run finishes, add a webhook on ACTOR.RUN.SUCCEEDED; its payload carries the run object, including defaultDatasetId.

Which part of Portugal are you planning to track on Imovirtual? Drop a comment! 💬