# NeoAuto Scraper (`normdata/neoauto-scraper`) Actor

Pull every car for sale in Peru in one run: lead-gen teams get the seller's real name, phone and WhatsApp, dealers track competitor pricing by brand and region, and researchers model price by year and mileage, straight from NeoAuto, with pagination that actually reaches what you ask for.

- **URL**: https://apify.com/normdata/neoauto-scraper.md
- **Developed by:** [Norm Data](https://apify.com/normdata) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $17.00 / 1,000 vehicles

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?

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

![Norm Data](https://raw.githubusercontent.com/FabriAV/normdata/refs/heads/main/assets/banner_norm2.png)

## 🚗 NeoAuto Scraper

Extract every car listing on **NeoAuto**, Peru's biggest car marketplace, make, model, year, price in USD, mileage, fuel, transmission, body type, location, and the seller's **real name, phone and WhatsApp**. No browser, **no proxy**, real pagination, CSV/JSON/Excel ready.

NeoAuto's listing pages are not gated behind any bot wall, this Actor reads the same structured data the site itself renders server-side, so every run is a plain, fast HTTP request. No workaround, no CAPTCHA, no browser automation.

### 🎯 Who uses it?

#### 📇 Lead-generation and sales teams

Pull the seller's public name, phone, and WhatsApp number straight from the listing, a ready-to-call lead, not just an ad.

#### 🚘 Dealerships

Track competitor stock and pricing by brand, body type, or department, and spot underpriced cars to flip.

#### 📊 Market researchers and pricing analysts

Build price-by-year-by-mileage datasets for any make and model in US dollars, NeoAuto's own pricing currency.

#### 🗂️ Data analysts and journalists

Snapshot Peru's used and new car market by department, fuel type, or vehicle category, on a schedule.

### ✨ What it does

- **Paste a search link, or use the filters.** Already built a search on neoauto.com? Paste that page's URL and it's reused exactly.
- **Real pagination.** NeoAuto tells you upfront how many listings and pages match, this Actor walks every page in order, several at once, instead of guessing or resampling.
- **The seller's real contact info.** Name, phone, and WhatsApp number, straight from the listing, not masked, not a contact form.
- **Every filter NeoAuto itself offers:** make, model, body type, fuel, transmission, department, price/year/mileage ranges, verified-only.
- **Optional deep enrichment.** Turn on Fetch extra detail to add color, number of doors, engine size (cc), drivetrain, district, the full description, and how long ago it was posted, all from each listing's own page.

### 🏆 Why this scraper

- **Zero proxy, zero browser, by design.** NeoAuto server-renders every listing's full data into the page itself, this Actor just reads it.
- **Real, honest pagination.** No resampling tricks: NeoAuto reports an exact total and page count, and this Actor walks it in order, so nothing is double-counted or missed.
- **Contact-ready leads.** Seller name, phone, and WhatsApp on every listing that publishes them, the actual point of a lead list.
- **Transparent about filter typos.** An unrecognized Make doesn't silently return the whole catalog disguised as a match, it's checked and reported as zero results.

### ⚖️ How it compares

| Capability | This actor | [scrapers_lat/neoauto-peru-scraper](https://apify.com/scrapers_lat/neoauto-peru-scraper) |
|---|:--:|:--:|
| Paste a search link from the site instead of filling filters | yes | yes |
| Dedicated price / year / mileage range filters | **yes** | no (URL-paste only) |
| Dedicated body type, fuel, transmission, department filters | **yes** | no (URL-paste only) |
| Verified-listings-only filter | **yes** | no |
| Seller's WhatsApp number | **yes** | not listed in their output fields |
| Optional per-listing enrichment (color, doors, engine cc, drivetrain, district, description, post age) | **yes** | no |
| Needs a browser or proxy | **no** | no |

### 📦 What data you get

| Field | Description |
| --- | --- |
| `listingId`, `url` | NeoAuto's internal listing ID and the canonical listing URL. |
| `title`, `year`, `make`, `model`, `version` | Full title plus its make, model, and trim/version. |
| `price`, `currency` | Listed price (always USD on NeoAuto). |
| `km` | Odometer reading. |
| `bodyType`, `fuel`, `transmission` | Vehicle specs. |
| `department`, `city` | Location in Peru, always included. |
| `color`, `doorNumber`, `engineCc`, `traction`, `district`, `description`, `publicationDate` | Color, number of doors, engine size (cc), drivetrain, exact district, the seller's full write-up, and how long ago it was posted. These seven only exist on the listing's own page: with Fetch extra detail off they're left out of the row entirely (not even `null`); turn it on to get them. |
| `sellerName`, `sellerPhone`, `sellerWhatsapp`, `sellerType` | The seller's public contact info and whether they're a `dealer` or `particular` (private). |
| `sellerLogo`, `publicationTier` | Dealer logo, and the listing's publication tier (e.g. `PREMIUM`). |
| `isVerified`, `isNew` | Whether NeoAuto marked the listing verified, and whether it's a brand-new (0 km) vehicle. |
| `mainImage`, `images` | Photo URLs. |
| `searchTerm`, `source`, `scrapedAt` | Which input produced this row, always `NeoAuto`, and the UTC timestamp. |

### 💡 Use cases

#### 📇 Build a dealer lead list for a brand

```json
{ "maxItems": 300, "make": "toyota", "sellerType": "dealer" }
```

#### 📊 Price a used Hyundai Tucson by year and mileage

```json
{ "maxItems": 200, "make": "hyundai", "model": "tucson", "kmMax": 80000 }
```

#### 🚘 Snapshot verified SUV listings under $20,000

```json
{ "maxItems": 150, "bodyType": "camionetas-suv", "priceMax": 20000, "verifiedOnly": true }
```

#### 🔗 Reuse a search you already built on the site

```json
{ "maxItems": 100, "pageUrl": "https://neoauto.com/venta-de-autos?marca=kia&departamento=arequipa" }
```

### ⚙️ How the input is organised

| Section | What it's for |
| --- | --- |
| **Maximum vehicles** | Always first, caps the whole run. |
| **Search** | Paste a search link, or Make and Model. |
| **Price, year and mileage** | Min/max price (USD), model year, and max mileage. |
| **Vehicle details** | Body type, fuel, transmission. |
| **Location** | Department. |
| **Seller** | Dealer vs. private, and verified-only. |
| **Advanced** | Extra detail enrichment and raw query parameters. |

### 💰 Pricing

Pay-per-event: **$0.003** when the run starts, plus a price per vehicle saved to your dataset. The per-vehicle price depends on your Apify plan tier:

| Your Apify plan | Price per vehicle |
| --- | --- |
| Free | $0.0200 |
| Bronze | $0.0190 |
| Silver | $0.0180 |
| Gold / Platinum / Diamond | $0.0170 |

Each vehicle is a full lead, not just a title and a link: year, make, model, price, mileage, fuel, transmission, body type, location, and the seller's real name, phone and WhatsApp.

New Apify accounts start with $5 in free credit.

### 🚀 Run it

1. Create a free Apify account with $5 in credit.
2. Open the NeoAuto Scraper.
3. Set Make, or any filter you need, set Maximum vehicles, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the Dataset tab.

Run it programmatically through the Apify API (`run-sync-get-dataset-items`) or the ApifyClient for JavaScript and Python.

### 🤖 Use with AI agents (MCP)

Give an AI agent live access to NeoAuto through the Model Context Protocol:

```
claude mcp add --transport http apify "https://mcp.apify.com?tools=normdata/neoauto-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### 🔧 Troubleshooting

**Why am I getting no results?**
Make, Model, Body type, and Department must match NeoAuto's own slugs exactly (see the examples in each field's description). An unrecognized Make is checked against the first page of real results and reported as zero matches, rather than silently returning unrelated listings.

**I pasted a search link and my filters below were ignored.**
That's expected, a pasted URL is reused exactly, and every filter below is intentionally skipped (the run log says so).

**Why don't I see color, doors, engine size, drivetrain, district, description or publication date?**
Those seven fields only exist on the listing's own page. With Fetch extra detail (in Advanced) off, they're left out of the row entirely rather than written as `null`, turn it on to add them (one extra request per listing, so it's off by default). Even with it on, a field stays missing if that specific seller never filled it in.

**Why did my run stop before reaching Maximum vehicles?**
NeoAuto's matching pool for that search is smaller than what you asked for, the run stops once it reaches the real last page, which the log reports.

### ❓ FAQ

| Question | Answer |
| --- | --- |
| Do I need a NeoAuto account or API key? | No. The Actor reads public listing data, so no login or API key is required. |
| Does this need a proxy? | No, never, NeoAuto server-renders listing data into the page itself. |
| Can I get the seller's phone number? | Yes, in `sellerPhone` and `sellerWhatsapp`, when the seller has published them. |
| Can I filter by dealer vs. private seller? | Yes, with the Seller type field. |
| What currency are prices in? | US dollars (USD), how NeoAuto itself prices every listing. |
| What output formats are supported? | CSV, JSON, Excel, or XML, from the Apify platform or API. |
| Is the data live? | Yes, each run reads the current NeoAuto listings. |
| Can I schedule regular scrapes? | Yes, use Apify's built-in Scheduler to run it daily, weekly, or at any interval. |

### 🛡️ Limits and responsible use

This Actor collects only publicly available listing data from NeoAuto. It never signs in and never touches private, internal, or paywalled pages.

Seller names, phone numbers, and WhatsApp numbers are personal/business data in some cases, use them in line with NeoAuto's terms and applicable law. NeoAuto's separate official "0 km" dealer showroom (a smaller, distinct inventory at `neoauto.com/venta-de-autos-nuevos`) is not covered, only the main marketplace is.

### 📧 Contact

Need a scraper for a different site, or found something wrong with this one? norm.data.scrapers@gmail.com

### 🧪 Local development

```powershell
bun install
bun test
bun run typecheck
apify run
```

Local results are stored in `storage/datasets/default`.

# Actor input Schema

## `maxItems` (type: `integer`):

Stop after this many listings. Leave empty for no limit (the run stops once the matching listings run out). The Apify Free plan is always capped at 10.

## `pageUrl` (type: `string`):

Already built a search on neoauto.com with the filters you want? Paste that page's URL here and this Actor reuses it exactly, every filter below is then ignored.

## `make` (type: `string`):

Brand slug as NeoAuto uses it, e.g. "toyota", "hyundai", "kia", "mercedes-benz". Leave empty for every make.

## `model` (type: `string`):

Model slug, e.g. "corolla", "tucson". Works best together with Make.

## `priceMin` (type: `integer`):

Only listings priced at or above this amount. NeoAuto prices everything in US dollars.

## `priceMax` (type: `integer`):

Only listings priced at or below this amount.

## `yearMin` (type: `integer`):

Oldest model year to include.

## `yearMax` (type: `integer`):

Newest model year to include.

## `kmMax` (type: `integer`):

Only listings with this many kilometers or fewer.

## `bodyType` (type: `string`):

Category as NeoAuto names it.

## `fuel` (type: `string`):

Engine fuel type.

## `transmission` (type: `string`):

Gearbox type.

## `department` (type: `string`):

Peruvian department where the vehicle is listed.

## `sellerType` (type: `string`):

Keep only private sellers or only dealers. Applied after fetching, like a client-side filter.

## `verifiedOnly` (type: `boolean`):

Keep only listings NeoAuto marks as verified (papers checked, no pending fines).

## `fetchDetails` (type: `boolean`):

Opens each listing's own page to add color, doors, engine size (cc), drivetrain, district, the full description, and how long ago it was posted. Slower, one extra request per listing, so it's off by default.

## `customQuery` (type: `string`):

Optional. Raw query string to append to the search, for anything not exposed above, e.g. "publicado=7dias" or "verificado=1\&publicado=hoy".

## Actor input object example

```json
{
  "maxItems": 10,
  "pageUrl": "https://neoauto.com/venta-de-autos?marca=toyota&anio_min=2018",
  "make": "toyota",
  "model": "corolla",
  "sellerType": "todos"
}
```

# Actor output Schema

## `vehicles` (type: `string`):

One row per listing.

# 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 = {
    "maxItems": 10,
    "bodyType": "",
    "fuel": "",
    "transmission": "",
    "department": "",
    "sellerType": "todos",
    "verifiedOnly": false,
    "fetchDetails": false
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "bodyType": "",
    "fuel": "",
    "transmission": "",
    "department": "",
    "sellerType": "todos",
    "verifiedOnly": False,
    "fetchDetails": False,
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "bodyType": "",
  "fuel": "",
  "transmission": "",
  "department": "",
  "sellerType": "todos",
  "verifiedOnly": false,
  "fetchDetails": false
}' |
apify call normdata/neoauto-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ggo6zHYZ7gLEMboPm/builds/REDrNGOiApEFoM0YG/openapi.json