# Standvirtual Scraper (`solidcode/standvirtual-scraper`) Actor

\[💰 $0.90 / 1K] Extract car listings from Standvirtual.com, Portugal's largest car marketplace — price, year, mileage, fuel, gearbox, make/model, seller, location, and photos. Search by make/model + filters, or paste a search URL.

- **URL**: https://apify.com/solidcode/standvirtual-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 13 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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?

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

Pull car listings from Standvirtual.com — Portugal's largest car marketplace — at scale: price, registration year, mileage, fuel, gearbox, engine power, make/model/version, seller details, location, and full photo galleries for every live listing. Build a search from structured filters or paste a Standvirtual URL — no result cap, so you can sweep the entire 43,000+ car catalog. Built for car dealers, automotive market analysts, and lead-generation teams who need Portuguese car inventory without copying URLs and details by hand.

### Why This Scraper?

- **No result cap — sweep all 43,000+ live listings** — set max results to 0 and pull the entire Standvirtual catalog in one run, not a capped sample. The leading competing actor stops at 2,000 cars per run.
- **11 structured search filters, no URL-building** — combine make, model, fuel type, body type, gearbox, dealer/private seller, and price/year/mileage bands directly in the input form. Or paste a Standvirtual search URL and skip filters entirely.
- **29 fields per car** — price and currency, registration year, mileage, fuel type, gearbox, engine power (hp) and capacity (cc), body type, doors, seats, color, make/model/version, seller details, location, region, cover photo and full gallery, promoted/highlighted flags, listing date, and the timestamp each row was collected.
- **8 fuel types and 9 body styles, every one a category Standvirtual publishes** — Petrol, Diesel, LPG, Hybrid, Plug-in Hybrid, Electric, CNG and Hydrogen; Small city car, City car, Compact, Sedan, Station wagon, SUV / Off-road, Coupe, Convertible and Minivan. Hybrid collects petrol and diesel hybrids together in one pass, because Standvirtual files them as two separate categories.
- **Dealer-vs-private seller split** — every row carries `sellerType` (dealer or private) plus the seller name, so you can segment professional inventory from individual sellers for lead-gen or market analysis.
- **Optional full photo galleries** — flip one switch to collect every photo on each listing (often 30+ images per car), not just the single cover thumbnail.
- **Engine specs on every listing** — engine power in horsepower and displacement in cubic centimeters parsed into clean numeric fields, ready for spec comparison.
- **8 sort orders** — order results by relevance, newest, price (low/high), mileage (low/high), or year (newest/oldest) before extraction.
- **Every category value published up front** — you filter in English and the rows return Standvirtual's own Portuguese labels (`Automática`, `SUV / TT`, `Elétrico`, `Cinzento`). All 2 gearbox, 8 fuel, 9 body-style and 14 color values are listed in this page, so your downstream matching works on the first run instead of the third.

### Use Cases

**Market Research**

- Map the entire live inventory of any make and model across Portugal
- Track median asking prices by fuel type, body style, or registration year
- Compare petrol vs. electric vs. hybrid supply and pricing over time
- Benchmark mileage-to-price curves across model years

**Dealer Intelligence**

- Monitor competitor dealer inventory by filtering on dealer seller type
- Watch how long specific models stay listed using the listing date field
- Identify which dealers carry the deepest stock in a segment
- Spot pricing gaps against your own showroom inventory

**Lead Generation**

- Build contact lists of private sellers by filtering on private seller type
- Capture seller names alongside each listing for outreach
- Target high-value segments by price, year, and make/model bands

**Price Monitoring**

- Track price changes on a saved search by re-running on a schedule
- Detect newly listed cars by sorting newest-first and watching listing dates
- Flag underpriced listings within a tight year and mileage band
- Compare promoted/highlighted listings against standard ones

**Data Enrichment & Integration**

- Feed structured Portuguese car data into valuation and analytics dashboards
- Power price-comparison and trade-in estimation tools
- Enrich CRM records with current market listings for a vehicle

### Getting Started

#### Scrape a Make and Model

The simplest way to start — name a make and model, keep the default limit:

```json
{
    "make": "BMW",
    "model": "320",
    "maxResults": 100
}
```

#### Filtered Search

Combine structured filters — diesel automatic SUVs under €25,000 from 2019 on, newest first:

```json
{
    "make": "Volkswagen",
    "fuelTypes": ["diesel"],
    "bodyTypes": ["suv"],
    "gearbox": "automatic",
    "priceMax": 25000,
    "yearMin": 2019,
    "sortBy": "newest",
    "maxResults": 500
}
```

#### Full Catalog from a Pasted URL

Paste any Standvirtual search URL and pull every matching listing with full photo galleries:

```json
{
    "searchUrls": [
        "https://www.standvirtual.com/carros/mercedes-benz/c-220"
    ],
    "includePhotos": true,
    "maxResults": 200
}
```

#### Advanced Multi-Filter Run

```json
{
    "make": "Audi",
    "model": "A4",
    "fuelTypes": ["diesel", "plugin-hybrid"],
    "bodyTypes": ["sedan", "station-wagon"],
    "gearbox": "automatic",
    "sellerType": "dealer",
    "priceMin": 10000,
    "priceMax": 40000,
    "yearMin": 2018,
    "yearMax": 2023,
    "mileageMax": 120000,
    "sortBy": "priceAsc",
    "includePhotos": true,
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `[]` | Paste one or more Standvirtual.com search-result URLs. When provided, these are used directly and the filter fields below are ignored. |

#### Build a Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | empty | Car manufacturer as shown on Standvirtual, e.g. "BMW", "Mercedes-Benz", "Renault". Leave empty for all makes. |
| `model` | string | empty | Model as it appears in the Standvirtual URL — usually the variant, e.g. "320", "C 220", "Clio", "Golf", "208". A whole range also works ("Serie 3", "Classe C") and returns every version in it. Leave empty for all models of the make. |
| `fuelTypes` | select\[] | `[]` | One or more of: Petrol, Diesel, LPG, Hybrid, Plug-in Hybrid, Electric, CNG (natural gas), Hydrogen. Hybrid returns petrol and diesel hybrids together. Leave empty for all fuel types. |
| `bodyTypes` | select\[] | `[]` | One or more of: Small city car, City car, Compact, Sedan, Station wagon, SUV / Off-road, Coupe, Convertible, Minivan / MPV. Leave empty for all body types. |
| `gearbox` | select | `Any` | Transmission: Any, Manual, or Automatic. |
| `sellerType` | select | `Any` | Listing source: Any, Dealer / Business, or Private seller. |

#### Price, Year & Mileage

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | empty | Only include cars at or above this price, in euros. |
| `priceMax` | integer | empty | Only include cars at or below this price, in euros. |
| `yearMin` | integer | empty | Only include cars first registered in or after this year, e.g. 2018. |
| `yearMax` | integer | empty | Only include cars first registered in or before this year. |
| `mileageMax` | integer | empty | Only include cars at or below this odometer reading, in kilometers. |

#### Sorting & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Most relevant` | Result order: Most relevant, Newest first, Price low→high, Price high→low, Mileage low→high, Mileage high→low, Year newest first, Year oldest first. Standvirtual offers no year order of its own, so the two Year choices rank the listings your run collects — set `maxResults` to `0` to rank every match. |
| `maxResults` | integer | `100` | Maximum listings to extract per search URL or search. An exact cap: you never receive or pay for more than this number. Set to 0 for unlimited (every listing the search returns). |
| `includePhotos` | boolean | `false` | When on, opens each listing to collect its full photo gallery (the `images` field). When off, you get a single cover photo per listing. |

### Output

Each car is one flat row in the dataset. Here's a representative result:

```json
{
    "id": "ID8Yabc1",
    "title": "BMW 320 d Touring Auto",
    "url": "https://www.standvirtual.com/carros/anuncio/bmw-320-d-touring-ID8Yabc1.html",
    "make": "BMW",
    "model": "320",
    "version": "d Touring Auto",
    "price": 28900,
    "currency": "EUR",
    "year": 2020,
    "mileage": 84500,
    "fuelType": "Diesel",
    "gearbox": "Automática",
    "enginePower": 190,
    "engineCapacity": 1995,
    "bodyType": "Carrinha",
    "doors": 5,
    "seats": 5,
    "color": "Preto",
    "shortDescription": "Full service history, one owner, financing available.",
    "sellerType": "dealer",
    "sellerName": "Auto Stand Lisboa",
    "location": "Lisboa",
    "region": "Lisboa",
    "image": "https://ireland.apollo.olxcdn.com/v1/files/example-cover.jpg",
    "images": [
        "https://ireland.apollo.olxcdn.com/v1/files/example-1.jpg",
        "https://ireland.apollo.olxcdn.com/v1/files/example-2.jpg"
    ],
    "isPromoted": true,
    "isHighlighted": false,
    "createdAt": "2026-06-10T09:15:00Z",
    "scrapedAt": "2026-06-13T11:42:00Z"
}
```

#### Values in the Data

You choose filters in English, and every row comes back carrying Standvirtual's own Portuguese labels, exactly as a visitor sees them on the site. Pick **Automatic** and the rows read `Automática`; pick **SUV** and they read `SUV / TT`; pick **Electric** and they read `Elétrico`. Match on the values below in your spreadsheet, database, or workflow, not on the English option names.

| Field | Values you'll see |
|-------|-------------------|
| `gearbox` | `Automática`, `Manual` |
| `fuelType` | `Gasolina`, `Diesel`, `Elétrico`, `Híbrido Plug-In`, `Híbrido (Gasolina)`, `Híbrido (Diesel)`, `GPL`, `GNC` |
| `bodyType` | `SUV / TT`, `Utilitário`, `Citadino`, `Carrinha`, `Sedan`, `Monovolume`, `Coupé`, `Cabrio`, `Pequeno citadino` |
| `color` | `Preto`, `Cinzento`, `Branco`, `Prateado`, `Azul`, `Vermelho`, `Verde`, `Castanho`, `Bege`, `Laranja`, `Dourado`, `Amarelo`, `Roxo`, `Outra` |
| `sellerType` | `dealer`, `private` — the one field that stays in English |
| `currency` | `EUR` |
| `region` | Portuguese districts: `Lisboa`, `Porto`, `Braga`, `Setúbal`, `Aveiro`, `Leiria`, `Santarém`, `Faro`, `Viana do Castelo`, `Vila Real`, `Coimbra`, `Viseu`, `Castelo Branco`, `Guarda`, `Portalegre`, `Beja`, `Évora`, `Bragança`, `Ilha da Madeira` |
| `make` | Standvirtual's own brand spelling, which is sometimes shorter than the name you searched: `BMW`, `Mercedes-Benz`, `Renault`, `Citroën`, `VW` (not "Volkswagen"), `MINI`, `SEAT` |

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Standvirtual listing identifier |
| `title` | string | Listing title as shown on Standvirtual |
| `url` | string | Direct link to the listing |
| `price` | number | Asking price |
| `currency` | string | Currency code (EUR) |
| `shortDescription` | string | Teaser description text (may be empty) |
| `createdAt` | string | Listing publish/update timestamp |
| `scrapedAt` | string | Timestamp (UTC) when this row was collected |

#### Vehicle Specs

| Field | Type | Description |
|-------|------|-------------|
| `make` | string | Manufacturer, spelled the way Standvirtual spells it (`VW`, `MINI`, `Citroën`) |
| `model` | string | Model name as Standvirtual lists it (`320`, `A4 Avant`, `Clio`) |
| `version` | string | Trim / version (e.g. "320 d Touring Auto") |
| `year` | number | First registration year |
| `mileage` | number | Odometer reading in kilometers |
| `fuelType` | string | Fuel, in Standvirtual's wording: `Gasolina`, `Diesel`, `Elétrico`, `Híbrido Plug-In`, `GPL` and the rest of the list above |
| `gearbox` | string | Transmission, in Standvirtual's wording: `Automática` or `Manual` |
| `enginePower` | number | Engine power in horsepower |
| `engineCapacity` | number | Engine displacement in cubic centimeters |
| `bodyType` | string | Body style, in Standvirtual's wording: `SUV / TT`, `Carrinha`, `Citadino`, `Utilitário`, `Sedan` and the rest of the list above |
| `doors` | number | Number of doors |
| `seats` | number | Number of seats |
| `color` | string | Exterior color, in Standvirtual's wording: `Preto`, `Cinzento`, `Branco`, `Prateado` and the rest of the list above |

#### Seller & Location

| Field | Type | Description |
|-------|------|-------------|
| `sellerType` | string | `dealer` or `private`, in English on every row |
| `sellerName` | string | Seller or dealership name |
| `location` | string | Portuguese city, town, or parish (`Sintra`, `Matosinhos`, `Queluz e Belas`) |
| `region` | string | Portuguese district (`Lisboa`, `Porto`, `Setúbal`) |

#### Media & Flags

| Field | Type | Description |
|-------|------|-------------|
| `image` | string | Primary cover photo URL |
| `images` | string\[] | All photo URLs for the listing (full gallery when photo collection is on; otherwise the cover photo) |
| `isPromoted` | boolean | Promoted / featured ad flag |
| `isHighlighted` | boolean | Highlighted (premium top) ad flag |

### Tips for Best Results

- **Leave max results at 0 for full-catalog coverage** — that pulls every car a search returns, with no 2,000-listing ceiling. Use a small number first (10–50) to preview the data, then scale up.
- **Use the filter fields instead of building URLs** — naming the make, model, and bands in the input form is faster and less error-prone than crafting a Standvirtual URL by hand.
- **Turn on photo collection only when you need galleries** — it opens each listing individually, so runs take longer and cost more. Leave it off when the single cover photo is enough.
- **Filter seller type for the right job** — choose Private seller for private-owner lead lists, or Dealer / Business to monitor competitor dealer stock.
- **Keep numeric bands inside the live data range** — a price or year band entirely beyond what's on the market (e.g. years 2099–2100) is ignored by Standvirtual and returns the full result set. A single open-ended bound (just a minimum or just a maximum) always works.
- **Sort newest-first to catch fresh listings** — pair Newest first with the listing date field to detect cars added since your last run.
- **Every fuel and body option is matched exactly, so a 0 means the market is empty** — each choice in those two dropdowns maps onto a category Standvirtual publishes itself, right down to Hydrogen and CNG, which are real categories with only a handful of cars between them on any given day. If one of them comes back empty, that is genuinely what is for sale, not a filter that missed. Standvirtual has no pickup or ethanol category at all, which is why neither is offered.
- **Name the model the way the Standvirtual URL does** — that is usually the variant designation ("320", "C 220", "Golf"), but a whole range works too ("Serie 3", "Classe C") and returns every version in it. If a make or model isn't recognized, the search is skipped and you're told which models are available — you're never charged for a catalog-wide result you didn't ask for.

### Pricing

**From $0.90 per 1,000 results** — flat pay-per-result pricing that undercuts the leading Standvirtual actor on the market. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.105 | $0.100 | $0.095 | $0.090 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is one car listing in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, dealer intelligence, and lead generation. You are responsible for complying with applicable laws and Standvirtual's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as seller names) in line with GDPR and other applicable privacy regulations.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Standvirtual.com search-result URLs. Go to standvirtual.com, set your filters in the browser (make, model, price, year, fuel...), and copy the URL from the address bar. When provided, these are used directly and the filter fields below are ignored.

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

Car manufacturer as shown on Standvirtual, e.g. 'BMW', 'Mercedes-Benz', 'Renault'. Leave empty for all makes. Ignored when search URLs are provided.

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

Model as it appears in the Standvirtual URL — usually the variant designation, e.g. '320', 'C 220', 'Clio', 'Golf', '208'. A whole range also works ('Serie 3', 'Classe C') and returns every version in it. If Standvirtual doesn't recognise the model, the search is skipped and you are told why, rather than returning every car of that make. Leave empty for all models of the chosen make.

## `fuelTypes` (type: `array`):

Only include cars with these fuel types. Leave empty for all fuel types. Every option matches a category Standvirtual actually publishes, and Hybrid covers both petrol and diesel hybrids. The rows come back with Standvirtual's own label, so Petrol reads 'Gasolina' and Electric reads 'Elétrico' in the data.

## `bodyTypes` (type: `array`):

Only include cars with these body types. Leave empty for all body types. These are the nine body styles Standvirtual itself lists. The rows come back with its own label, so SUV reads 'SUV / TT' and Station wagon reads 'Carrinha' in the data.

## `gearbox` (type: `string`):

Transmission type. The rows come back with Standvirtual's own label: Automatic reads 'Automática' and Manual reads 'Manual' in the data.

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

Only include listings from this kind of seller. 'Dealer / Business' keeps professional sellers; 'Private seller' keeps individuals. This is applied to each listing after it is fetched, so it never hides any results that match your other filters.

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

Only include cars at or above this price, in euros. Leave empty for no lower bound.

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

Only include cars at or below this price, in euros. Leave empty for no upper bound.

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

Only include cars first registered in or after this year, e.g. 2018. Leave empty for no lower bound.

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

Only include cars first registered in or before this year. Leave empty for no upper bound.

## `mileageMax` (type: `integer`):

Only include cars at or below this odometer reading, in kilometers, e.g. 150000. Leave empty for no upper bound.

## `sortBy` (type: `string`):

How to order the search results before they are extracted. Ignored when search URLs already include a sort order. Standvirtual itself offers no registration-year order, so the two Year options are applied to the listings this run collects — set Maximum results to 0 (no limit) if you want every matching car ranked by year.

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

Maximum number of listings to extract per search URL or search. This is an exact cap — you never get (or pay for) more than this number. Set to 0 for unlimited (gets every listing the search returns).

## `includePhotos` (type: `boolean`):

When on, the actor opens each listing to collect its full photo gallery (the 'images' field). When off, you get a single cover photo per listing. Turning this on roughly doubles the work per listing, so it takes longer and costs more — leave it off unless you need every photo.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.standvirtual.com/carros/renault/clio"
  ],
  "fuelTypes": [],
  "bodyTypes": [],
  "gearbox": "any",
  "sellerType": "any",
  "sortBy": "relevance",
  "maxResults": 100,
  "includePhotos": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of car listings with key fields.

## `specs` (type: `string`):

Make, model, year, mileage, fuel, gearbox, body style, color, and engine details. Category values use Standvirtual's own Portuguese labels (Automática, SUV / TT, Elétrico, Preto).

## `seller` (type: `string`):

Seller type (dealer or private, in English) plus the Portuguese city and district for each 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 = {
    "searchUrls": [
        "https://www.standvirtual.com/carros/renault/clio"
    ],
    "make": "",
    "model": "",
    "fuelTypes": [],
    "bodyTypes": [],
    "gearbox": "any",
    "sellerType": "any",
    "sortBy": "relevance",
    "maxResults": 100,
    "includePhotos": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchUrls": ["https://www.standvirtual.com/carros/renault/clio"],
    "make": "",
    "model": "",
    "fuelTypes": [],
    "bodyTypes": [],
    "gearbox": "any",
    "sellerType": "any",
    "sortBy": "relevance",
    "maxResults": 100,
    "includePhotos": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchUrls": [
    "https://www.standvirtual.com/carros/renault/clio"
  ],
  "make": "",
  "model": "",
  "fuelTypes": [],
  "bodyTypes": [],
  "gearbox": "any",
  "sellerType": "any",
  "sortBy": "relevance",
  "maxResults": 100,
  "includePhotos": false
}' |
apify call solidcode/standvirtual-scraper --silent --output-dataset

```

## MCP server setup

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