# Webmotors Scraper - Brazil Cars, Cheapest Flat Price (`gio21/webmotors-scraper-v2`) Actor

Extract Webmotors.com.br car listings in clean JSON: make, model, version, price, photo and listing URL. Flat $0.003 per car, no tiered plan markup, up to 70% cheaper than other Webmotors scrapers on the Apify Store. No login or CAPTCHA needed.

- **URL**: https://apify.com/gio21/webmotors-scraper-v2.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 24 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 car scrapeds

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Webmotors Scraper - Brazil Cars, Cheapest Flat Price

### Why use this scraper

Webmotors.com.br is Brazil's largest used and new car marketplace, with hundreds of thousands of active listings across every brand, model and city in the country. Pulling that inventory by hand, or scraping it yourself, means fighting a JavaScript-heavy search page, anti-bot defenses, and listing pages that change structure every few months. This actor does the extraction for you: point it at any Webmotors brand, model or search listing page and get back clean, structured JSON of every car on that page, ready to load into a spreadsheet, a pricing model or a lead pipeline, at a flat price that does not punish you for being on a free or lower-tier Apify plan.

### Overview

Input is one or more Webmotors listing URLs (brand pages, model pages or filtered search results). Output is one JSON record per car: title, make, model, version/trim, price in BRL, availability, a stable listing ID, the main photo URL, the direct listing URL and the source page it came from. A typical run against a single brand page in a single city returns dozens of cars in under a minute; multiple start URLs (different brands, cities or pages) can be queued in the same run to cover more ground. Billing is per car returned, at $0.003 each, with no per-run platform fee layered on top beyond Apify's own compute minimum.

### Supported inputs

- **Brand listing pages** - e.g. `https://www.webmotors.com.br/carros/sp-sao-paulo/honda`, returns every Honda listing shown on that page.
- **Model or filtered search pages** - any Webmotors URL under `/carros/` or `/comprar/` that renders a vehicle search results grid (brand plus model, price range, year range, city, etc., as built by Webmotors' own search filters).
- **Multiple URLs per run** - `startUrls` accepts an array, so you can combine several cities, brands or filter combinations in a single run instead of starting a new one for each.
- The actor reads whatever Webmotors renders on that exact URL; it does not click through Webmotors' own pagination links, so for large result sets pass the URLs for each page you want (Webmotors exposes a `?page=N` style parameter on most listing URLs).

### Use cases

- **Dealership market research** - pull every competitor listing for a given make and city to benchmark asking prices before pricing your own stock.
- **Price monitoring for marketplaces or classifieds aggregators** - track how Webmotors prices for a specific model move week over week.
- **Lead generation for car buyers' agents** - build a feed of new listings matching a client's brand, budget and trim preferences without manually refreshing search pages.
- **Academic or journalistic research on the Brazilian used car market** - collect a representative sample of asking prices by brand, model or region for analysis.
- **Fintech and insurance pricing models** - feed real asking prices into a vehicle valuation or insurance quoting model that needs a live market reference, not a stale catalog.

### How it works

Webmotors renders its listing pages with the vehicle catalog embedded as `OfferCatalog` structured data (JSON-LD) directly in the page HTML, the same schema.org markup Google uses to understand product listings for search. Instead of trying to read prices and titles off the visual layout, which Webmotors restyles periodically, this actor parses that embedded JSON-LD block directly. Each `Vehicle` entry in the catalog carries its own price, image and canonical listing URL; the actor also derives make, model and version/trim from the listing URL's own path segments, which Webmotors keeps in a consistent, URL-safe format. Reading the structured data instead of the rendered DOM makes the actor noticeably more resistant to Webmotors' routine front-end redesigns.

### Input configuration

**Single brand, single city:**

```json
{
  "startUrls": ["https://www.webmotors.com.br/carros/sp-sao-paulo/honda"],
  "maxResults": 100
}
```

**Multiple brands and cities in one run:**

```json
{
  "startUrls": [
    "https://www.webmotors.com.br/carros/rj/honda",
    "https://www.webmotors.com.br/carros/mg-belo-horizonte/toyota",
    "https://www.webmotors.com.br/carros/pr-curitiba/volkswagen"
  ],
  "maxResults": 300
}
```

**Specific model with a higher retry count for a flaky connection window:**

```json
{
  "startUrls": ["https://www.webmotors.com.br/carros/sp-sao-paulo/honda/hr-v"],
  "maxResults": 50,
  "maxRetries": 6
}
```

### Output sample

Real items from a production run against `webmotors.com.br/carros/rj/honda`:

```json
[
  {
    "position": 1,
    "title": "HONDA HR-V 1.5 DI I-VTEC FLEX EXL CVT",
    "make": "Honda",
    "model": "Hr V",
    "version": "15 di i vtec flex exl cvt",
    "price": 141000,
    "currency": "BRL",
    "availability": "https://schema.org/InStock",
    "listingId": "77733151",
    "imageUrl": "https://image.webmotors.com.br/_fotos/anunciousados/gigante/2026/202608/20260815/hondahrv15diivtecflexexlcvt-WMIMAGEM09015220771.jpg",
    "url": "https://www.webmotors.com.br/comprar/honda/hr-v/15-di-i-vtec-flex-exl-cvt/4-portas/2024-2025/77733151",
    "sourceUrl": "https://www.webmotors.com.br/carros/rj/honda"
  },
  {
    "position": 2,
    "title": "HONDA FIT 1.5 LX 16V FLEX 4P AUTOMATICO",
    "make": "Honda",
    "model": "Fit",
    "version": "15 lx 16v flex 4p automatico",
    "price": 76000,
    "currency": "BRL",
    "availability": "https://schema.org/InStock",
    "listingId": "78638024",
    "imageUrl": "https://image.webmotors.com.br/_fotos/anunciousados/gigante/2026/202608/20260831/hondafit15lx16vflex4pautomatico-WMIMAGEM15064015642.jpg",
    "url": "https://www.webmotors.com.br/comprar/honda/fit/15-lx-16v-flex-4p-automatico/4-portas/2019/78638024",
    "sourceUrl": "https://www.webmotors.com.br/carros/rj/honda"
  }
]
```

### Key output fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Full listing title as shown on Webmotors |
| `make` | string | Vehicle brand, derived from the listing URL |
| `model` | string | Vehicle model, derived from the listing URL |
| `version` | string | Trim/version string (engine, finish level, transmission) |
| `price` | number | Asking price |
| `currency` | string | Always `BRL` |
| `availability` | string | Schema.org availability status reported by Webmotors |
| `listingId` | string | Webmotors' own numeric ID for the listing, stable across re-scrapes |
| `imageUrl` | string | Main listing photo |
| `url` | string | Direct link to the listing on Webmotors |
| `sourceUrl` | string | The start URL this record was found on |

### Pricing

Pay-per-result, one event per car returned:

| Event | Price |
|-------|-------|
| Car scraped | $0.003 |

That price is flat: it does not change whether you are on Apify's Free plan or a paid tier. By contrast, the two largest other Webmotors scrapers on the Store charge per-vehicle prices that start at roughly $0.01 on the Free tier (see comparison below). For a 1,000-car run this actor costs $3; a tiered-pricing competitor charging $0.01/vehicle on Free costs $10 for the same run.

### What makes this richer than the competition

Two other publishers run Webmotors scrapers on the Apify Store today:

- **`ribtools/webmotors-scraper`** (24 users in the last 30 days) charges a tiered per-vehicle price starting around $0.00999 on the Free plan (dropping only to $0.00699 on paid tiers), plus a separate "Add-on Seller Data" charge for seller info and a further add-on for FIPE market price data. This actor's flat $0.003 per car is roughly 70% cheaper than that scraper's own Free-tier rate, with no plan-dependent markup and no add-on fees to track.
- **`stealth_mode/webmotors-auto-search-scraper`** (4 users) targets the same search-results use case with a similar tiered pricing model, aimed at dealerships and market-analysis teams.

Where this actor is more limited: it does not offer a seller-data add-on or a FIPE historical price add-on like `ribtools/webmotors-scraper`. If you need seller contact details or Webmotors' own FIPE valuation history on top of the asking price, that competitor's add-ons cover that; this actor is built for teams that just need clean listing and price data at the lowest possible per-record cost.

### Notes & limitations

- The actor reads whatever Webmotors renders at the exact URL you provide. It does not paginate through "load more" or next-page links on its own; queue each page's URL in `startUrls` if you need more results than a single page returns.
- Output does not include vehicle year, mileage, seller name or listing location as separate fields. Year and city information can usually be read off the `title` string and the brand/city segment of `sourceUrl`, but they are not broken out into their own fields in this version.
- `version` is the raw trim string from the URL (lowercase, hyphens replaced with spaces); it is not normalized against a fixed trim list.
- Webmotors occasionally serves a listing page with no `OfferCatalog` block (empty search results, or a page under maintenance). In that case the actor returns an `{error: "no_listings"}` record for that URL instead of silently skipping it, so you can tell an empty result from a failed fetch.
- Free Apify accounts receive a single mock sample record instead of live data; running this actor against real Webmotors pages requires a paid Apify account in good standing.

### FAQ

**Does this work for new cars as well as used?**
Yes, as long as the Webmotors URL you provide renders a listing grid with the `OfferCatalog` structured data; both new and used inventory sections use the same markup.

**Can I filter by price range or year directly in the actor?**
There is no in-actor filter. Build the filtered URL on Webmotors itself (using its own search filters) and pass that URL to the actor; the actor returns exactly what that URL shows.

**Why is `model` sometimes written oddly, like "Hr V" instead of "HR-V"?**
`model` is derived automatically from the listing URL's path segment and capitalized word by word; Webmotors' own URL slugs don't always match its marketing capitalization.

**What happens if a listing is sold between my scrape and when I view it?**
`availability` reflects Webmotors' status at scrape time. Listings can be sold or removed quickly on a fast-moving marketplace; re-run the actor to refresh availability.

**Does the price change based on my Apify plan?**
No. This actor charges a flat $0.003 per car regardless of your Apify plan tier, unlike the other Webmotors scrapers on the Store, whose per-vehicle price depends on your plan.

**Can I run this against multiple cities or brands at once?**
Yes, list every URL you want covered in `startUrls`; each one is fetched and billed independently within the same run.

### For AI Agents & LLM Apps

This actor is available over the Apify MCP server (`mcp.apify.com`) for direct use from Claude, Cursor or any MCP-compatible agent, and over the plain REST API for scripted pipelines.

Synchronous call that returns dataset items directly, no polling required:

```bash
curl "https://api.apify.com/v2/acts/gio21~webmotors-scraper-v2/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["https://www.webmotors.com.br/carros/sp-sao-paulo/honda"], "maxResults": 100}'
```

Keep `maxResults` close to what you actually need per call; a single brand/city page usually returns well under 100 listings, so there is rarely a reason to request thousands of results from one start URL.

### Disclaimer

This actor is an independent tool that extracts publicly available listing data from Webmotors.com.br. It is not affiliated with, endorsed by or sponsored by Webmotors or its parent companies. "Webmotors" is a registered trademark of its respective owner. Use it in line with Webmotors' own terms and any applicable data protection law in your jurisdiction.

### SEO Keywords

Webmotors scraper, Webmotors API, Brazil car listings scraper, Webmotors price scraper, used car data Brazil, Webmotors JSON data, carros Webmotors scraper.

# Actor input Schema

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

URLs to scrape. See README for supported formats.

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

Cap on total records returned. Default 100.

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

Retries on upstream block. Default 3.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.webmotors.com.br/carros/sp-sao-paulo/honda"
  ],
  "maxResults": 100,
  "maxRetries": 3
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.webmotors.com.br/carros/sp-sao-paulo/honda"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": ["https://www.webmotors.com.br/carros/sp-sao-paulo/honda"] }

# Run the Actor and wait for it to finish
run = client.actor("gio21/webmotors-scraper-v2").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.webmotors.com.br/carros/sp-sao-paulo/honda"
  ]
}' |
apify call gio21/webmotors-scraper-v2 --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lrZK13njlfX0NvNTa/builds/8UNtA5171TfIlJfXI/openapi.json