# StandVirtual Scraper - Portugal Used Car Listings (`rastriq/standvirtual-scraper`) Actor

Scrape used car listings from standvirtual.com, Portugal's largest car marketplace: price in EUR, mileage, year, fuel, gearbox, dealer or private seller, location and photo. Same field names as the other Rastriq car scrapers. No login.

- **URL**: https://apify.com/rastriq/standvirtual-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 listing returneds

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

## StandVirtual Scraper

**StandVirtual Scraper** extracts used car listings from standvirtual.com, Portugal's largest car marketplace: price in EUR, mileage, year, fuel, gearbox, dealer or private seller, location and photo. Run your search by brand, model, fuel, price and year, and export a clean, de-duplicated dataset to JSON, CSV or Excel; no browser, no login.

> Part of the Rastriq car-marketplace family: the core fields (`id`, `title`, `make`, `model`, `year`, `km`, `hp`, `price`, `currency`, `fuel_type`, `gearbox`, `city`, `region`, `is_professional`, `url`, `img_url`, `source`, `scraped_at`) are identical across countries, and source-specific extras are prefixed `ext_`. Datasets from several countries can be stacked without re-mapping.

### What data you get with StandVirtual Scraper

StandVirtual Scraper returns one flat record per listing. Fields the source does not provide are `null`; nothing is guessed.

| Field | Type | Description |
|---|---|---|
| `id` | string | StandVirtual listing ID. |
| `title` | string (nullable) | Listing title as published. |
| `make` | string (nullable) | Car brand. |
| `model` | string (nullable) | Car model. |
| `version` | string (nullable) | Trim / engine version (null when the title has none). |
| `year` | integer (nullable) | First registration year. |
| `km` | integer (nullable) | Mileage in kilometres. |
| `hp` | integer (nullable) | Engine power in hp, as entered by the seller. |
| `price` | integer (nullable) | Asking price in whole EUR. |
| `currency` | string | ISO 4217 currency code, always EUR. |
| `fuel_type` | string (nullable) | Fuel as shown on the listing (Gasolina, Diesel, Elétrico, Híbrido, Híbrido Plug-In...). |
| `gearbox` | string (nullable) | Transmission as shown (Manual, Automática). |
| `origin` | string (nullable) | Nacional or Importado; null when the seller does not state it. |
| `city` | string (nullable) | Seller city or parish. |
| `region` | string (nullable) | District (distrito). |
| `is_professional` | boolean (nullable) | true for dealers (professional stand), false for private sellers. |
| `url` | string (nullable) | Direct link to the listing on standvirtual.com. |
| `img_url` | string (nullable) | Main photo (thumbnail 320x240). |
| `source` | string | Always standvirtual. |
| `scraped_at` | string | UTC extraction timestamp, ISO 8601. |

### How to use StandVirtual Scraper

1. Open **StandVirtual Scraper** on Apify and click **Try for free**.
2. Optionally set `make` and `model` with the slugs from the StandVirtual URL (for example `bmw` and `serie-3`), plus fuel, price and year filters.
3. Set **Max pages** (32 listings per page) and **Max items**. The prefill (1 page, 20 items) is a cheap first test.
4. Keep the default Apify proxy and click **Start**.
5. Download the dataset from the **Output** tab as JSON, CSV or Excel, or read it through the API.

Typical uses of StandVirtual Scraper:

- Track used car prices in Portugal by make, model and year
- Monitor dealer stock (`is_professional`) and new arrivals, sorted newest first
- Compare Portuguese prices with Spain, Poland, Romania or Germany using the same field names

### Input example

The prefilled input of StandVirtual Scraper (a cheap first run):

```json
{
  "maxPages": 1,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `make` | string | — | — | Brand slug exactly as in the StandVirtual URL, lowercase. Examples: `bmw`, `audi`, `mercedes-benz`. Leave empty for all brands. |
| `model` | string | — | — | Model slug as in the URL, lowercase. Needs a make. Examples: `serie-3` (with `bmw`), `a4` (with `audi`). |
| `fuel` | string | any | — | Only return cars with this fuel type. |
| `minPrice` | integer | — | — | Lowest asking price in euros, for example `5000`. |
| `maxPrice` | integer | — | — | Highest asking price in euros, for example `20000`. |
| `minYear` | integer | — | — | Oldest first-registration year, for example `2018`. |
| `maxYear` | integer | — | — | Newest first-registration year, for example `2024`. |
| `maxPages` | integer | `3` | `1` | Maximum number of result pages to read (32 listings per page). Use 1 for a quick test. |
| `maxItems` | integer | `50` | `20` | Maximum number of listings to return in total. Example: `20` costs about $0.045. |
| `proxyConfiguration` | object | Apify Proxy | Apify Proxy | Apify datacenter proxy is enough for normal runs, no residential traffic is needed. If StandVirtual blocks you (HTTP 403), the Actor retries with a fresh IP; as a last resort select RESIDENTIAL with country `PT`. |

### Output example

A real record returned by StandVirtual Scraper:

```json
{
  "id": "8097729319",
  "title": "BMW 320 d Auto",
  "make": "BMW",
  "model": "320",
  "version": "d Auto",
  "year": 2025,
  "km": 17256,
  "hp": 190,
  "price": 41900,
  "currency": "EUR",
  "fuel_type": "Diesel",
  "gearbox": "Automática",
  "origin": "Nacional",
  "city": "Porto",
  "region": "Porto",
  "is_professional": true,
  "url": "https://www.standvirtual.com/carros/anuncio/bmw-320-ver-d-auto-ID8Q1fjp.html",
  "img_url": "https://ireland.apollo.olxcdn.com/v1/files/zwubt357cd201-STDVTLPT/image;s=320x240",
  "source": "standvirtual",
  "scraped_at": "2026-10-24T20:25:41+00:00"
}
```

### Pricing

StandVirtual Scraper uses pay-per-event pricing: **$0.005 per run start** plus **$0.002 per listing** ($2.00 per 1,000). You only pay for unique listings delivered to the dataset; a run that returns nothing charges no listings.

| Run | Cost in events |
|---|---|
| 20 listings (prefill) | $0.045 |
| 50 listings (default run) | $0.105 |
| 1,000 listings | $2.005 |
| 10,000 listings | $20.005 |

StandVirtual Scraper works from Apify datacenter IPs, so no residential proxy traffic is billed.

Tip: start with the prefilled input, check the output, then raise `maxPages` and `maxItems`.

### Limitations

- Only search-result data is returned. Detail-page fields (description, equipment, seller phone) are not collected.
- `km`, `hp` and `origin` depend on what each seller entered; missing values are `null`.
- Results are sorted newest first, which keeps pages stable during the run. Duplicate listing IDs are removed.
- Tested pagination: a search announcing 83 results (BMW Série 3, 2024 onwards) returned exactly 83 unique listings over 3 pages.
- The site sometimes answers HTTP 403 to a datacenter IP. The Actor retries up to 4 times with a fresh IP and, if StandVirtual still blocks the first page, fails with a clear message and returns no listings.

### Related Actors

Other Rastriq car-marketplace scrapers with the same core fields:

| Country | Actor | Notes |
|---|---|---|
| Portugal | [CustoJusto Scraper](https://apify.com/rastriq/custojusto-scraper) | general classifieds, many private sellers |
| Turkey | [Arabam.com Scraper](https://apify.com/rastriq/arabam-scraper) | used cars |
| Switzerland | [Comparis.ch Scraper](https://apify.com/rastriq/comparis-scraper) | with comparis market price |
| Poland | [OtoMoto Scraper](https://apify.com/rastriq/otomoto-scraper) | largest Polish marketplace |
| Romania | [Autovit Scraper](https://apify.com/rastriq/autovit-scraper) | Romanian marketplace |
| Spain | [Coches.net Scraper](https://apify.com/rastriq/cochesnet-spain) | Spain's top marketplace |

### FAQ

**Is it legal to scrape standvirtual.com?** StandVirtual Scraper reads publicly visible listing pages at a low request rate, without logging in or bypassing access controls, and it does not extract seller names or phone numbers. Check the website terms and make sure your use of the data complies with the law that applies to you, including data protection rules.

**Does StandVirtual Scraper need a proxy?** The default Apify datacenter proxy is enough in normal runs and adds no extra cost. If you are blocked (HTTP 403), the Actor rotates the IP automatically; as a last resort choose Apify Proxy RESIDENTIAL with country `PT`.

**How often should I run StandVirtual Scraper?** Listings change daily. For price monitoring a weekly run is a good balance; for new-arrival alerts run it daily with a narrow filter and `maxItems` set low.

**Can I schedule StandVirtual Scraper or call it from my code?** Yes. Use Apify schedules, the API, or integrations such as Make, Zapier or Google Sheets to run it automatically and send the dataset on.

**Something broke or a field is missing?** standvirtual.com changes its pages from time to time. Open an issue on the Actor page and include the run link.

# Actor input Schema

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

Brand slug exactly as in the StandVirtual URL, lowercase. Examples: <code>bmw</code>, <code>audi</code>, <code>mercedes-benz</code>. Leave empty for all brands.

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

Model slug as in the URL, lowercase. Needs a make. Examples: <code>serie-3</code> (with <code>bmw</code>), <code>a4</code> (with <code>audi</code>).

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

Only return cars with this fuel type.

## `minPrice` (type: `integer`):

Lowest asking price in euros, for example <code>5000</code>.

## `maxPrice` (type: `integer`):

Highest asking price in euros, for example <code>20000</code>.

## `minYear` (type: `integer`):

Oldest first-registration year, for example <code>2018</code>.

## `maxYear` (type: `integer`):

Newest first-registration year, for example <code>2024</code>.

## `maxPages` (type: `integer`):

Maximum number of result pages to read (32 listings per page). Use 1 for a quick test.

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

Maximum number of listings to return in total. Example: <code>20</code> costs about $0.045.

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

Apify datacenter proxy is enough for normal runs, no residential traffic is needed. If StandVirtual blocks you (HTTP 403), the Actor retries with a fresh IP; as a last resort select <b>RESIDENTIAL</b> with country <code>PT</code>.

## Actor input object example

```json
{
  "fuel": "",
  "maxPages": 1,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Used car listings extracted from standvirtual.com.

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

Pages read, rows seen and the result count announced by StandVirtual.

# 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 = {
    "maxPages": 1,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/standvirtual-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 = {
    "maxPages": 1,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/standvirtual-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 '{
  "maxPages": 1,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/standvirtual-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/standvirtual-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/qJh9TFtXs7a8tPj2E/builds/dXkRQR9mYOcJKYXFG/openapi.json