# Avito.ru Listings Scraper (`w3crawler/avito-listings-scraper`) Actor

Extract public Avito listings, prices, seller information, product specifications, and optional reviews.

- **URL**: https://apify.com/w3crawler/avito-listings-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Avito.ru Listings Scraper

Collect public **Avito.ru** classified listings from search pages, generated category searches, or direct listing URLs. Each row keeps the public listing identity, title, price, images, seller and location details, category path, and optional automotive or product fields that Avito exposes. The Actor supports multiple source URLs, bounded pagination, local filters and sorting, deduplication, optional detail enrichment, and a public seller phone only when that phone is already visible on the page.

### Get started

1. Open the [Actor Store page](https://apify.com/w3crawler/avito-listings-scraper) and select **Try for free**, or open the **Input** tab directly.
2. Add public Avito search or category pages to `searchUrls`, or supply direct `listingUrls`. To build a URL from `query`, `location`, and `category`, leave both `searchUrls` and the compatibility `searchUrl` empty.
3. Keep `maxResults`, `maxPages`, and `maxDetailRequests` small for the first run. Disable `includeDetails` for a fast search-card-only snapshot.
4. Start the Actor, open the dataset, and export the rows as JSON, CSV, or Excel. Open **Run summary** (`OUTPUT_SUMMARY`) to check counts and source blocking.

### Input

All fields are optional; the table defaults come from `.actor/input_schema.json`. Unsupported field names and out-of-range values are rejected before requests start.

| Field | Type | Required? | Default | Meaning |
| --- | --- | --- | --- | --- |
| `searchUrl` | string | Optional | `https://www.avito.ru/moskva/telefony` | One public HTTPS Avito search URL. Compatibility field used only when `searchUrls` is absent. |
| `searchUrls` | string array | Optional | Not supplied | Up to ten public HTTPS Avito search or category URLs. Pages from every URL are combined and deduplicated when enabled. |
| `listingUrls` | string array | Optional | Not supplied | Up to 500 direct HTTPS Avito listing URLs or numeric listing IDs. When supplied, these become the only targets and each is parsed as a detail page. |
| `query` | string | Optional | Not supplied | Keywords used to build a search URL only when neither `searchUrls` nor a usable `searchUrl` is supplied. |
| `location` | string | Optional | `Россия` | City or region path used when the Actor builds a search URL, for example `Москва` or `Санкт-Петербург`. |
| `category` | string | Optional | `all` | Category slug used when the Actor builds a search URL; `all` leaves the URL at the location root. |
| `priceMin` | integer | Optional | Not supplied | Lower price parameter added to a generated search URL, from 0 to 1,000,000,000 RUB. |
| `priceMax` | integer | Optional | Not supplied | Upper price parameter added to a generated search URL, from 0 to 1,000,000,000 RUB. |
| `sort` | string enum | Optional | `relevance` | Source ordering hint added to a generated URL: `relevance`, `newest`, `cheapest`, or `expensive`. |
| `pageParameter` | string enum | Optional | `p` | Query parameter used for pages after the first: `p` or `page`. |
| `maxPages` | integer | Optional | `1` | Maximum public result pages requested per search URL, from 1 to 20. |
| `deduplicate` | boolean | Optional | `true` | Remove repeated listing IDs or URLs found across pages and source URLs. |
| `sortBy` | string enum | Optional | `input_order` | Local order applied after filtering: `input_order`, `price_asc`, `price_desc`, `rating_desc`, or `title_asc`. |
| `filters` | object | Optional | `{}` | Wrapper for the local filters below. Filters use only public values already present in the row. |
| `filters.includeKeywords` | string array | Optional | `[]` | Keep a row only when every listed term appears in its public text; at most 20 terms. |
| `filters.excludeKeywords` | string array | Optional | `[]` | Drop a row when any listed term appears in its public text; at most 20 terms. |
| `filters.minPrice` | number | Optional | Not supplied | Keep rows whose normalized `price` is at or above this amount, from 0 to 1,000,000,000. |
| `filters.maxPrice` | number | Optional | Not supplied | Keep rows whose normalized `price` is at or below this amount, from 0 to 1,000,000,000. |
| `filters.minRating` | number | Optional | Not supplied | Keep rows whose public seller or listing rating is at or above this value, from 0 to 5. |
| `filters.locationContains` | string | Optional | Not supplied | Keep rows whose public `location` contains this text, up to 200 characters. |
| `maxResults` | integer | Optional | `100` | Maximum unique listing rows stored after filters and sorting, from 1 to 500. |
| `includePhone` | boolean | Optional | `false` | Retain `sellerPhone` only when a phone number is already exposed in public page text. The Actor does not reveal hidden numbers. |
| `includeDetails` | boolean | Optional | `true` | Keep detail-page fields such as description, address, attributes, seller details, and structured product data, and allow bounded detail requests for search results. |
| `maxDetailRequests` | integer | Optional | `20` | Maximum listing detail pages requested for search-result enrichment, from 0 to 500. When omitted entirely through the API, the effective limit is `min(maxResults, 20)`. A direct `listingUrls` target is already a detail page and does not use this budget again. |
| `includeReviews` | boolean | Optional | `true` | Keep public seller rating, review summary, listing rating, and review count when present. |
| `includeImages` | boolean | Optional | `true` | Keep public image URLs exposed by cards or detail pages. |
| `maxImages` | integer | Optional | `20` | Maximum image URLs retained per row, from 0 to 20. |
| `developerOptions` | object | Optional | `{}` | Wrapper for the bounded request controls below. These settings do not bypass source access controls. |
| `developerOptions.requestDelayMs` | integer | Optional | `250` | Pause before each live public request, from 0 to 10,000 ms. |
| `developerOptions.maxConcurrency` | integer | Optional | `2` | Maximum concurrent public detail requests, from 1 to 5. |
| `developerOptions.maxRequestRetries` | integer | Optional | `1` | Retries with 1/2/4-second backoff for transient transport failures and HTTP 408/500/502/503/504, from 0 to 3. Security checks, access denials, HTTP 429/439, and proxy authentication failures are not retried. |
| `developerOptions.requestTimeoutSecs` | integer | Optional | `30` | Timeout for each live public request, from 5 to 120 seconds. |
| `developerOptions.maxResponseBytes` | integer | Optional | `5000000` | Maximum accepted response or fixture size, from 1,000 to 15,000,000 bytes. |
| `developerOptions.userAgent` | string | Optional | Not supplied | Transparent request user-agent label, up to 300 characters. |
| `requestTimeoutSecs` | integer | Optional | Not supplied | Legacy top-level alias for `developerOptions.requestTimeoutSecs`, 5 to 120. |
| `timeoutMs` | integer | Optional | Not supplied | Legacy millisecond timeout alias, 1,000 to 120,000; converted to seconds. |
| `requestDelayMs` | integer | Optional | Not supplied | Legacy top-level alias for `developerOptions.requestDelayMs`, 0 to 10,000. |
| `maxConcurrency` | integer | Optional | Not supplied | Legacy top-level alias for `developerOptions.maxConcurrency`, 1 to 5. |
| `maxRequestRetries` | integer | Optional | Not supplied | Legacy top-level alias for `developerOptions.maxRequestRetries`, 0 to 3. |
| `maxResponseBytes` | integer | Optional | Not supplied | Legacy top-level response-size alias, 1,000 to 15,000,000 bytes. |
| `maxBytes` | integer | Optional | Not supplied | Older response-size alias, 1,000 to 15,000,000 bytes. |
| `userAgent` | string | Optional | Not supplied | Legacy top-level alias for `developerOptions.userAgent`, up to 300 characters. |
| `proxyConfiguration` | object | Optional | Not supplied | Optional standard Apify Proxy editor object. Use ordinary proxy transport only when direct public access is blocked. |

Example input adapted from the saved detail-off run (`.actor/input.json`); the run's provider-specific proxy group is omitted:

```json
{
  "searchUrls": [
    "https://www.avito.ru/moskva/telefony"
  ],
  "maxPages": 1,
  "pageParameter": "p",
  "deduplicate": true,
  "sortBy": "input_order",
  "maxResults": 3,
  "includePhone": false,
  "includeDetails": false,
  "includeReviews": false,
  "includeImages": true,
  "maxImages": 3,
  "maxDetailRequests": 0,
  "developerOptions": {
    "requestDelayMs": 0,
    "maxConcurrency": 1,
    "maxRequestRetries": 3,
    "requestTimeoutSecs": 30,
    "maxResponseBytes": 8000000
  },
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

The Actor reads public Avito.ru HTML over HTTPS. If `listingUrls` is present, those targets are used instead of search URLs. Otherwise, at least one search URL must be available directly or built from `query`, `location`, and `category`. Local filters, the deduplication pass, `sortBy`, and `maxResults` are applied after extraction; a detail failure keeps the base search-card row and increments the operational counters in `OUTPUT_SUMMARY`.

### Output

The dataset contains one row per unique public listing. Optional properties are omitted when the source does not expose them; no diagnostic or placeholder rows are written.

| Field | Type | Availability | Meaning |
| --- | --- | --- | --- |
| `id` | integer | Always | Numeric Avito listing identifier observed on the page. |
| `title` | string | Always | Listing title shown by Avito. |
| `url` | string | Always | Normalized public listing URL. |
| `listingUrl` | string | Always | Listing URL as captured from the source page. |
| `sourceUrl` | string | Always | Search or direct listing page that produced this row. |
| `searchUrl` | string | Always | Search page recorded for the extraction context; a direct listing target records that listing URL. |
| `pageNumber` | integer | Always | One-based source page number. |
| `position` | integer | Always | One-based position of the listing on its source page. |
| `price` | number | Always | Normalized numeric listing price. |
| `currency` | string | Always | Currency reported by the page, normally `RUB`. |
| `priceFormatted` | string | Always | Price text shown by Avito. |
| `images` | string array | Always | Bounded public image URLs, capped by `maxImages`. |
| `category` | string | When published | Public listing category. |
| `categoryHierarchy` | string array | When published | Public category path, when the page exposes one. |
| `sellerName` | string | When published | Public seller name. |
| `sellerType` | string | When published | Public seller account type. |
| `sellerPhone` | string | When published | Phone text only when publicly visible and `includePhone` is enabled. |
| `sellerRating` | number | When published | Public seller rating from 0 to 5. |
| `sellerReviewSummary` | string | When published | Public seller review count or summary text. |
| `description` | string | When published | Public listing description from the card or detail page. |
| `location` | string | When published | Public city or locality. |
| `address` | string | When published | Public detail-page address, when exposed. |
| `specificParams` | string | When published | Compact parameter line shown on the search card. |
| `parameters` | string | When published | Expanded parameter text from a detail page. |
| `vehicle` | object | When published | Open object of automotive attributes when the listing is a vehicle; keys vary by listing. |
| `attributes` | object | When published | Open object of detail-page key/value attributes; keys vary by listing. |
| `rating` | number | When published | Public listing or product rating from 0 to 5. |
| `reviewCount` | integer | When published | Public listing or product review count. |
| `isFeatured` | boolean | Always | Whether public page markup marks the listing as featured. |
| `badges` | string array | When published | Bounded public listing badges. |
| `publishedAt` | string | When published | Publication timestamp or source text. |
| `brand` | string | When published | Public brand when detail data exposes it. |
| `model` | string | When published | Public model when detail data exposes it. |
| `condition` | string | When published | Public condition label. |
| `canonicalUrl` | string | When published | Canonical listing URL when the page exposes one. |
| `scrapedAt` | string | Always | UTC timestamp when the row was saved. |

`vehicle` and `attributes` are open objects, so their keys depend on the listing category and the fields published by Avito; the dataset schema does not fix a key list. `images`, `categoryHierarchy`, and `badges` are arrays of public strings. The saved run used `includeDetails: false`, so all three rows contain the same 14 search-card fields and omit the detail-only properties.

The example is a real saved row from the 2026-10-25 run. All values are complete.

```json
{
  "id": 4168837752,
  "title": "iPhone 13, 128 ГБ, SIM + eSIM",
  "url": "https://www.avito.ru/moskva/telefony/iphone_13_128_gb_sim_esim_4168837752?context=H4sIAAAAAAAA_wE_AMD_YToyOntzOjEzOiJsb2NhbFByaW9yaXR5IjtiOjA7czoxOiJ4IjtzOjE2OiJKZlhOSXN2WjlCNUJENWM1Ijt9KSOG8z8AAAA",
  "listingUrl": "https://www.avito.ru/moskva/telefony/iphone_13_128_gb_sim_esim_4168837752?context=H4sIAAAAAAAA_wE_AMD_YToyOntzOjEzOiJsb2NhbFByaW9yaXR5IjtiOjA7czoxOiJ4IjtzOjE2OiJKZlhOSXN2WjlCNUJENWM1Ijt9KSOG8z8AAAA",
  "sourceUrl": "https://www.avito.ru/moskva/telefony",
  "searchUrl": "https://www.avito.ru/moskva/telefony",
  "pageNumber": 1,
  "position": 1,
  "price": 24990,
  "currency": "RUB",
  "priceFormatted": "24 990 ₽",
  "images": [
    "https://60.img.avito.st/image/1/1.CrbHZLaApl_RxARe32QO47fFpFt106JfdbTHW3Vnp_1yx6JF0cQEXnE.e5yBZ00splEDIBw77Cc-OAoN52pA16XXyjCmzkyeFfo",
    "https://c60.img.avito.st/image/1/1.Cd14PraApTRungc1ZgIHoH-fpzDKiaE0yu7EMMo9pJbNnaEubp4HNc4.UoV2Qfqvps3DFpzYpbBIuYDzrVtXuzcNhnDrqHi88mQ",
    "https://c90.img.avito.st/image/1/1.MRn8QLaAnfDq4D_xkgRpYeThn_RO95nwTpD89E5DnFJJ45nq6uA_8Uo.FlI7uce-Jg01tHRvo1IPKEpKrNO5gK90ZF9Pk7O1k5o"
  ],
  "isFeatured": false,
  "scrapedAt": "2026-10-25T20:53:23.609Z"
}
```

### Run summary

**Run summary** is stored separately from the dataset in the run's key-value store under `OUTPUT_SUMMARY`; a backward-compatible copy is also written under `OUTPUT`. The run logs contain the issue details behind the counters.

| Field | Meaning |
| --- | --- |
| `status` | Actor outcome. A clean empty or partial result is still `SUCCEEDED`. |
| `runStatus` | Canonical run status; matches `status`. |
| `dataStatus` | Completeness of the saved source data: `COMPLETE`, `PARTIAL`, `NO_RESULTS`, or `FAILED`. |
| `recordCount` | Source-backed listing rows saved to the dataset. |
| `listingCount` | Listing rows saved; mirrors `recordCount` for this Actor. |
| `diagnosticCount` | Operational issues counted for the run. |
| `diagnosticItems` | Diagnostic dataset rows; always 0. |
| `errorCount` | Operational failures recorded for the run. |
| `recordsEmitted` | Source-backed listing rows successfully emitted. |
| `requestedUrlCount` | Number of public source URLs requested. |
| `requestCount` | Total source requests attempted. |
| `retries` | Retry attempts performed. |
| `successfulRequests` | Requests that returned usable responses. |
| `pagesFetched` | Search result pages fetched successfully. |
| `detailPagesFetched` | Listing detail pages fetched successfully. |
| `candidateItems` | Listings found before local filters and the final cap. |
| `filteredCount` | Candidates removed by configured filters. |
| `duplicateCount` | Candidates removed as duplicates. |
| `blockedCount` | Requests classified as blocked. |
| `sourceBlocked` | Whether a public source access boundary was observed. |
| `proxyEnabled` | Whether standard Apify Proxy routing was active. |
| `maxResults` | Listing cap used for the run. |
| `maxPages` | Per-URL page cap used for the run. |
| `sortBy` | Local output sort used for the run. |
| `sourceUrl` | Primary public source URL for the run. |
| `completedAt` | UTC time the summary was written. |

| Status | Data status | Meaning |
| --- | --- | --- |
| `SUCCEEDED` | `COMPLETE` | Eligible listings were saved without an extraction problem. |
| `SUCCEEDED` | `PARTIAL` | Listings were saved, but a later page or detail request failed. Saved rows remain available. |
| `SUCCEEDED` | `NO_RESULTS` | The source completed cleanly and returned no matching listings. |
| `FAILED` | `FAILED` | A fatal error occurred before any usable listing was saved. |

Example `OUTPUT_SUMMARY` from the 2026-10-25 run:

```json
{
  "status": "SUCCEEDED",
  "runStatus": "SUCCEEDED",
  "dataStatus": "COMPLETE",
  "recordCount": 3,
  "listingCount": 3,
  "diagnosticCount": 0,
  "diagnosticItems": 0,
  "errorCount": 0,
  "recordsEmitted": 3,
  "requestedUrlCount": 1,
  "requestCount": 1,
  "retries": 0,
  "successfulRequests": 1,
  "pagesFetched": 1,
  "detailPagesFetched": 0,
  "candidateItems": 50,
  "filteredCount": 0,
  "duplicateCount": 0,
  "blockedCount": 0,
  "sourceBlocked": false,
  "proxyEnabled": true,
  "maxResults": 3,
  "maxPages": 1,
  "sortBy": "input_order",
  "sourceUrl": "https://www.avito.ru/moskva/telefony",
  "completedAt": "2026-10-25T20:53:23.902Z"
}
```

### Coverage and limitations

The Actor reads public Avito.ru search and listing HTML. It does not log in, call private APIs, solve CAPTCHA or security checks, or bypass access controls. Search cards expose fewer fields than detail pages; properties such as `description`, `address`, `sellerName`, `location`, `category`, `parameters`, `vehicle`, `attributes`, `badges`, `publishedAt`, and `canonicalUrl` require source data that a given page may not publish. When `includeDetails` is false or `maxDetailRequests` is 0, saved rows remain search-card snapshots.

`searchUrl` is a compatibility field: it is ignored when `searchUrls` is supplied. `listingUrls` replaces search targets entirely, and each direct listing is treated as a detail page. Phone numbers are never revealed or inferred; `sellerPhone` is retained only if Avito already shows the number in public text and `includePhone` is enabled. Blocked, empty, or partial responses are counted in `OUTPUT_SUMMARY` and described in run logs rather than turned into placeholder rows. A failed detail request normally keeps the base listing, so a successful run can still contain fewer detail fields than expected.

### Usage and support

Cost depends on search pages, direct or detail pages, response size, retries, concurrency, and retained image URLs. Start with one search URL, `maxResults` of 3 to 10, `maxPages` of 1, and `includeDetails` disabled; enable detail enrichment only after the search-card shape is confirmed. See the Actor's Pricing tab for current account rates.

Use the [Actor Issues page](https://apify.com/w3crawler/avito-listings-scraper/issues) to report a problem. Include the run ID, the input used, and the `OUTPUT_SUMMARY`; do not include tokens, cookies, or private data. This Actor is not affiliated with or endorsed by Avito. Use it only for public data and in accordance with Avito's terms, robots guidance, and applicable law. Public listings can contain personal information; use the output only for lawful purposes.

# Actor input Schema

## `searchUrl` (type: `string`):

One public HTTPS Avito search URL. Use searchUrls for multiple sources.

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

Up to ten public HTTPS Avito search or category URLs. Pages are combined and deduplicated when enabled.

## `listingUrls` (type: `array`):

Optional direct HTTPS Avito listing URLs or numeric listing IDs. When present, each page is treated as a detail target.

## `query` (type: `string`):

Keywords used when no searchUrl or searchUrls value is supplied.

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

Avito city or region for a generated URL, for example Москва or Санкт-Петербург.

## `category` (type: `string`):

Optional Avito category slug used for a generated URL.

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

Optional lower price filter for a generated URL.

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

Optional upper price filter for a generated URL.

## `sort` (type: `string`):

Ordering hint for a generated Avito search URL.

## `pageParameter` (type: `string`):

Query parameter used for pages after the first page.

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

Bound the number of public pagination pages requested for each search URL.

## `deduplicate` (type: `boolean`):

Remove repeated listing IDs or URLs across pages and search URLs.

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

Sort extracted rows after filtering.

## `filters` (type: `object`):

Local filters applied only to fields publicly exposed by Avito.

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

Maximum unique listing rows stored after filters and sorting.

## `includePhone` (type: `boolean`):

Keep a phone number only when it is exposed in public page text.

## `includeDetails` (type: `boolean`):

Keep public descriptions, locations, attributes, seller details, and structured product fields.

## `maxDetailRequests` (type: `integer`):

Bound the number of listing detail pages requested for enrichment.

## `includeReviews` (type: `boolean`):

Keep public rating and review counts when present.

## `includeImages` (type: `boolean`):

Keep bounded image URLs exposed by listing cards or detail pages.

## `maxImages` (type: `integer`):

Maximum public image URLs retained for each row.

## `developerOptions` (type: `object`):

Operational controls for bounded public requests. These options do not bypass source access controls.

## `requestTimeoutSecs` (type: `integer`):

Legacy top-level alias; prefer developerOptions.requestTimeoutSecs.

## `timeoutMs` (type: `integer`):

Legacy top-level alias; prefer developerOptions.requestTimeoutSecs.

## `requestDelayMs` (type: `integer`):

Legacy top-level alias; prefer developerOptions.requestDelayMs.

## `maxConcurrency` (type: `integer`):

Legacy top-level alias; prefer developerOptions.maxConcurrency.

## `maxRequestRetries` (type: `integer`):

Legacy top-level alias; prefer developerOptions.maxRequestRetries.

## `maxResponseBytes` (type: `integer`):

Legacy top-level alias; prefer developerOptions.maxResponseBytes.

## `maxBytes` (type: `integer`):

Legacy top-level alias; prefer developerOptions.maxResponseBytes.

## `userAgent` (type: `string`):

Legacy top-level alias; prefer developerOptions.userAgent.

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

Optional standard Apify Proxy configuration. Use ordinary proxy transport only when direct public access is blocked.

## Actor input object example

```json
{
  "searchUrl": "https://www.avito.ru/moskva/telefony",
  "location": "Россия",
  "category": "all",
  "sort": "relevance",
  "pageParameter": "p",
  "maxPages": 1,
  "deduplicate": true,
  "sortBy": "input_order",
  "filters": {},
  "maxResults": 100,
  "includePhone": false,
  "includeDetails": true,
  "maxDetailRequests": 20,
  "includeReviews": true,
  "includeImages": true,
  "maxImages": 20,
  "developerOptions": {}
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runSummary` (type: `string`):

Run status and counters stored by the Actor.

## `sourceMetadata` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/avito-listings-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/avito-listings-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 '{}' |
apify call w3crawler/avito-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,w3crawler/avito-listings-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/mR5P5hyjm9SudwdED/builds/BeH45Wn0ITE0oivW5/openapi.json