# Webmotors API (`truefetch/webmotors-api`) Actor

Webmotors API for public Brazil vehicle inventory by keyword. Return 37 normalized fields for BRL prices, vehicle attributes, images, listing IDs, and source URLs with Webmotors-only routing.

- **URL**: https://apify.com/truefetch/webmotors-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 4.00 out of 5 stars

## Pricing

from $6.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

**Webmotors API is a webmotors api that searches public Brazil vehicle inventory by keyword and returns 37 normalized fields with BRL prices, listing IDs, images, and source URLs.**

- **Brazil and Webmotors are fixed by the focused runtime route.**
- **A three-input contract keeps the first API request compact.**
- **Webmotors inventory paths are derived from the submitted vehicle phrase.**
- **Qualifying rows retain the original `/comprar/` destination or other source URL.**

[**Run a one-result test**](https://apify.com/truefetch/webmotors-api) · [**View API**](https://apify.com/truefetch/webmotors-api/api)

Set `max_results` to `1` for the smallest useful test. Billing includes Actor Start and only the result rows actually written to the default Dataset.

### What does Webmotors API do?

Webmotors API turns a public vehicle search into structured Dataset rows for Brazil through public Webmotors vehicle inventory. It accepts the current schema inputs, follows the edition's routing rules, and writes source-linked records that can move directly into JSON, CSV, Excel, a database, or another Apify workflow.

Webmotors' official guide explains searching by make or model and opening the full advertisement from the result list, which matches the source-linked discovery scope documented here. [See the official Webmotors vehicle-search guide](https://ajuda.webmotors.com.br/hc/pt-br/articles/10574802681364-Escolhendo-seu-ve%C3%ADculo).

The Actor is a collection and normalization tool, not a vehicle-history report, appraisal, inspection, financing decision, or guarantee of current stock. Important commercial facts should be checked on `source_url`, because listings and catalog pages can change after collection.

### How do I run Webmotors API?

Run Webmotors API by starting with its prefilled scenario, reviewing one source-linked row, and increasing scope only after the data matches the intended workflow.

1. Open the [Webmotors API input page](https://apify.com/truefetch/webmotors-api) and review every required value.
2. Set `country` to `Brazil`, `keyword` to `Toyota Corolla`, and `max_results` to `11`; for the smallest risk test, temporarily use `max_results: 1`.
3. Start the Actor and wait for the default Dataset.
4. Open `source_url` from a returned row before expanding the result ceiling or scheduling repeats.

```json
{
  "max_results": 11,
  "country": "Brazil",
  "keyword": "Toyota Corolla"
}
```

The result limit is a ceiling rather than a promise. Live inventory, source access, unique listing URLs, and the fields available on each page determine how many records can be published.

### What data does Webmotors API return?

Webmotors API returns one object per source record using exactly 37 public fields. Values unavailable from the source remain empty; the Actor does not derive a VIN, seller, mileage, location, or vehicle specification from the keyword.

| Field group | Public fields | Meaning |
| --- | --- | --- |
| Identity and price | `main_image`, `title`, `price`, `currency`, `year`, `make`, `model`, `trim` | Primary media, listing title, asking price, and vehicle identity. |
| Mileage and geography | `mileage`, `mileage_unit`, `location`, `latitude`, `longitude`, `country` | Odometer values and source-published place data. |
| Source and seller | `platform`, `source_url`, `seller`, `seller_type` | Marketplace attribution, original listing link, and public seller context. |
| Vehicle attributes | `condition`, `body_type`, `seats`, `fuel`, `transmission`, `engine`, `drive_type`, `exterior_color`, `interior_color`, `vin` | Source-published condition, dimensions, powertrain, colors, and identifiers. |
| Lifecycle and content | `listing_id`, `posted_at`, `updated_at`, `description`, `images`, `price_text`, `official_url`, `processor`, `processed_at` | Source identity, dates, descriptive content, additional links, and processing attribution. |

This abbreviated illustrative item uses the same scenario; a real row follows the full 37-field schema.

```json
{
  "main_image": "https://example.com/webmotors/toyota-corolla.jpg",
  "title": "Toyota Corolla 2.0 Flex",
  "price": 119990,
  "currency": "BRL",
  "year": 2021,
  "make": "Toyota",
  "model": "Corolla",
  "mileage": 56635,
  "mileage_unit": "km",
  "country": "Brazil",
  "platform": "Webmotors",
  "listing_id": "123456",
  "source_url": "https://www.webmotors.com.br/comprar/example/123456",
  "processed_at": "2026-08-10T08:03:44Z"
}
```

Apify Datasets support JSON, JSONL, CSV, Excel, XML, HTML, and RSS retrieval through the [Dataset items API](https://docs.apify.com/api/v2/dataset-items-get). Keep `source_url` and `processed_at` when exporting so later reviews retain both source provenance and collection time.

### What inputs can I configure?

Webmotors API exposes only inputs supported by its current runtime route, with required fields marked explicitly and no invented non-empty fallback for optional filters.

| Input | Type | Required | Behavior | Example |
| --- | --- | --- | --- | --- |
| `max_results` | integer | Yes | Maximum Webmotors records returned by the run. | `11` |
| `country` | string | Yes | Required market input; this edition accepts Brazil. | `"Brazil"` |
| `keyword` | string | Yes | Required make, model, or vehicle phrase converted to the native inventory path. | `"Toyota Corolla"` |

The complete effective test input is formed from schema defaults overridden by prefills. API callers can replace those values, but must still send each required field with a schema-valid value.

### What platforms and markets does Webmotors API cover?

Webmotors API covers Brazil through public Webmotors vehicle inventory; coverage follows the source relationships registered for this edition rather than assumptions based on the Actor's title.

The public market is Brazil and the platform is Webmotors. There is no cross-source fallback.

The input does not expose city because the implemented request builds a countrywide keyword inventory path. Location may still appear in a row when the source publishes it.

Source inventory, language, seller-entered fields, and page availability change independently. The Dataset describes what was available when the run processed each record.

### Why use Webmotors API?

Webmotors API is useful when a repeatable API and Dataset contract matters more than manually copying vehicle cards or maintaining a source-specific export parser.

| Capability | Practical benefit |
| --- | --- |
| Webmotors-only attribution | Keep Brazil inventory samples tied to the intended marketplace. |
| Native keyword path | Search a make or model without pretending to support an unused location control. |
| BRL and listing identifiers | Prepare price and identity comparisons from structured values. |
| 37 normalized columns | Reuse the same downstream table across repeated searches. |
| Source-linked records | Open the advertisement before acting on availability or vehicle facts. |

Search-result collection is lightweight and source-linked, but fields visible only on deeper pages may remain empty. This is why null handling and source-link retention are part of a reliable downstream design rather than cleanup tasks.

### Who is Webmotors API for?

Webmotors API is designed for developers, Brazil automotive analysts, pricing teams, inventory monitors, dealer researchers, and data operations specialists. It works for teams that need a reproducible input, structured output, and a review path back to each public source record.

Toyota Corolla supply checks, BRL asking-price samples, listing-ID monitoring, image review queues, model-level inventory snapshots, and recurring internal dashboards fit the source. Eleven results exercise the configured ceiling without implying complete market coverage.

It is not an inspection, registration record, fair-value guarantee, financing offer, seller-consent tool, or comprehensive licensed feed. Vehicle purchases, lending, insurance, safety, and regulatory decisions require independent checks beyond a scraped public listing.

### How can I use Webmotors API through the API or MCP?

Webmotors API has the public Actor ID `DoyzIE16h33veHj1v`; the stable name form `truefetch/webmotors-api` is also available for human-readable integrations.

```text
DoyzIE16h33veHj1v
```

This synchronous HTTP request uses the same scenario and returns Dataset items directly:

```bash
curl -L "https://api.apify.com/v2/acts/DoyzIE16h33veHj1v/run-sync-get-dataset-items?maxItems=1" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -d '{"max_results":11,"country":"Brazil","keyword":"Toyota Corolla"}'
```

Apify also provides a hosted Streamable HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=actors,docs"
    }
  }
}
```

After authentication, ask the MCP client to inspect Actor ID `DoyzIE16h33veHj1v`, run the same input, and return the default Dataset rows. The [Webmotors API API page](https://apify.com/truefetch/webmotors-api/api) provides generated SDK and OpenAPI examples, while the [Apify MCP guide](https://docs.apify.com/integrations/mcp) documents current client setup.

### How much does Webmotors API cost?

Webmotors API costs $0.00800 per result on the FREE tier plus $0.01000 per Actor Start event; memory determines the number of Start events at one per GB, minimum one.

| Event or tier | Price | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01000 | Per GB of Actor memory, minimum one event. |
| Result — FREE | $0.00800 | One item written to the default Dataset. |
| Result — BRONZE | $0.00720 | One Dataset item. |
| Result — SILVER | $0.00640 | One Dataset item. |
| Result — GOLD | $0.00600 | One Dataset item. |
| Result — PLATINUM | $0.00600 | One Dataset item. |
| Result — DIAMOND | $0.00600 | One Dataset item. |

Smallest-test calculation, assuming the minimum one Start event: $0.01000 Actor Start + 1 result × $0.00800 = **$0.01800**. A run that writes no row can still incur Actor Start. Check the [live pricing page](https://apify.com/truefetch/webmotors-api/pricing) before budgeting a larger workflow because prices can change.

### How does Webmotors API compare with alternatives?

Webmotors API is the best fit when its documented source and normalized contract match the job; broader, manual, or contractual approaches solve different problems.

| Option | Best fit | Trade-off |
| --- | --- | --- |
| Webmotors API | Repeatable Webmotors discovery with normalized output. | Search responses may not expose every native detail. |
| Car Listings API | Country-aware research across many vehicle sources. | Its broad routing is unnecessary for Webmotors-only work. |
| Manual Webmotors browsing | A small buying task requiring full page interaction. | Hard to export and compare on a schedule. |
| A dedicated commercial feed | Guaranteed terms or source-specific field completeness. | Different contractual and integration requirements. |

No option eliminates the need to verify a mutable vehicle advertisement before a purchase or other high-impact decision.

### What are the limits and troubleshooting steps?

Webmotors API depends on public source responses, so troubleshooting begins with the exact input, the current source page, and whether the default Dataset contains a row.

| Symptom or limit | Explanation and next step |
| --- | --- |
| Fewer than eleven rows arrive | The cap is not a stock guarantee; live inventory and unique links determine output. |
| Optional columns are empty | Search cards and structured page data expose only part of the shared schema. |
| Another country is rejected | Brazil is the accepted market for the Webmotors edition. |
| No location input exists | The implemented source request is a countrywide keyword path. |
| A source page is unavailable | Retry later and include the run ID plus a public URL in an Issue. |

For a reproducible report, use `max_results: 1`, include the run ID and exact input, and add one public source URL when available. Never include an Apify token, private seller data, or credentials in an [Issue](https://apify.com/truefetch/webmotors-api/issues).

### Frequently asked questions

#### Which inputs are required?

`max_results`, `country`, and `keyword` are all required.

#### Is this a webmotors car listings api?

Yes. It converts public Webmotors inventory results into normalized Apify Dataset rows.

#### Can it serve as a brazil used car listings api?

Yes for Webmotors-sourced public inventory, but it does not claim every Brazilian marketplace or registration record.

#### Can I filter by city?

Not through the current input. City can appear in output when the source record provides it.

#### Is there a free Brazil car API?

The Actor uses pay-per-event billing; a small test may fit within Apify plan allowances but is not an unlimited free feed.

#### Can I schedule runs to monitor Webmotors inventory over time?

Yes. Reuse the Toyota Corolla input and compare price, listing ID, and source URL across scheduled Datasets.

#### Why can details be missing?

A search page may expose fewer attributes than the full advertisement, and the Actor does not invent them.

### Related TrueFetch Actors

Three TrueFetch Actors cover the closest adjacent vehicle markets without duplicating this Actor's exact source scope.

- [Car Listings API](https://apify.com/truefetch/car-listings-api) — Use it for multiple markets or sources.
- [CarDekho API](https://apify.com/truefetch/cardekho-api) — Use it for India vehicle records.
- [Autohome API](https://apify.com/truefetch/autohome-api) — Use it for Mainland China vehicle records.

### Support

Use the [Store page](https://apify.com/truefetch/webmotors-api) for the input, the [API page](https://apify.com/truefetch/webmotors-api/api) for generated integration examples, and [Issues](https://apify.com/truefetch/webmotors-api/issues) for a reproducible bug. Discuss vehicle-data workflows in the [TrueFetch community on Telegram](https://t.me/TrueFetch).

[**Run a focused Webmotors API test**](https://apify.com/truefetch/webmotors-api) · [**Open the Webmotors API API**](https://apify.com/truefetch/webmotors-api/api)

**Last Updated:** August 10, 2026

# Actor input Schema

## `max_results` (type: `integer`):

Maximum public Webmotors inventory records returned by this Brazil run.

## `country` (type: `string`):

Required market input; this source-locked Webmotors API accepts Brazil.

## `keyword` (type: `string`):

Required Webmotors make, model, or vehicle phrase converted to the native inventory search path.

## `platforms` (type: `array`):

Source selector fixed to Webmotors for this edition.

## `location` (type: `string`):

Optional contract field; Webmotors rejects locations it cannot send through a native source request.

## Actor input object example

```json
{
  "max_results": 5,
  "country": "Brazil",
  "keyword": "Toyota Corolla",
  "platforms": [
    "Webmotors"
  ]
}
```

# Actor output Schema

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

Open the overview table for normalized vehicle listings from the selected supported platforms.

# 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 = {
    "max_results": 5,
    "country": "Brazil",
    "keyword": "Toyota Corolla",
    "platforms": [
        "Webmotors"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/webmotors-api").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 = {
    "max_results": 5,
    "country": "Brazil",
    "keyword": "Toyota Corolla",
    "platforms": ["Webmotors"],
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/webmotors-api").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 '{
  "max_results": 5,
  "country": "Brazil",
  "keyword": "Toyota Corolla",
  "platforms": [
    "Webmotors"
  ]
}' |
apify call truefetch/webmotors-api --silent --output-dataset

```

## MCP server setup

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

```

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/DoyzIE16h33veHj1v/builds/HRxxCCsUWCzbTxJif/openapi.json