# Ozon Scraper — Products, Prices, Specs, Reviews & Sellers (`logiover/ozon-scraper`) Actor
Scrape Ozon.ru by keyword or category. Extract product name, price, discount, rating, review count, images, badges and stock at scale. No API key, no login. For price monitoring, e-commerce analytics and market research.
- **URL**: https://apify.com/logiover/ozon-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.50 / 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/platform/actors/running/actors-in-store#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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).
If your project is in a different language, use 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
## Ozon Scraper — Products, Prices, Discounts, Ratings & Reviews (No API Key)
    
An **unofficial Ozon scraper** and structured **Ozon product data API** in a single Apify Actor. Search **Ozon.ru** — Russia's largest online marketplace — by keyword or crawl an entire category, and export clean, flat product data: names, live prices, discounts, Ozon-Card prices, ratings, review counts, images, seller badges and stock. Powered directly by **Ozon's own web JSON API** — no API key, no login, no headless browser. Just fast HTTP behind a Russian residential proxy, and structured JSON you can pour into CSV, Excel or a database. Every result is tagged with `_mode` so you can mix keyword and category runs in one dataset and filter later.
> ### 🏆 Why this Ozon scraper?
> Search **or** category crawl · **hundreds–thousands of products per run** via deep pagination · live `price`, `originalPrice`, `discountPercent` and `cardPrice` as real numbers · `rating` + `reviewCount` on every tile · product images and badges · export to JSON / CSV / Excel. The unofficial **Ozon API alternative** for price monitoring, e-commerce analytics, competitor research and market intelligence — with **no API key** and **no browser**.
---
### ✨ What this Actor does / Key features
- 🔎 **Keyword search** — search Ozon by any Russian or English term (`iphone`, `наушники`, `робот-пылесос`) and paginate the full result set into a clean product dataset.
- 🗂️ **Category crawl** — feed an Ozon category slug or URL and walk the whole catalogue page by page for bulk extraction (10k+ products in a single run).
- 💰 **Full pricing** — `price`, `originalPrice` (strike-through), `discountPercent` and the special Ozon-Card `cardPrice`, all stored as real numbers in rubles (`RUB`).
- ⭐ **Ratings & reviews** — `rating` (e.g. `4.9`) and `reviewCount` on every product tile that has them.
- 🖼️ **Media & badges** — every product's image gallery (`images[]`), plus seller/quality `badges[]` such as “Оригинal” (Original), and a human-readable `stockText` and `deliveryDate`.
- 🧭 **Runs with empty input** — no field is required; an empty run browses a popular default search bounded by `maxResults`.
- 🔁 **Deep, de-duplicated pagination** — rides Ozon's virtual-scroll paginator and de-dupes products across pages so you pay only for unique rows.
- 🛡️ **Anti-block engine** — solves Ozon's two-step `__Secure-ETC` cookie handshake and rotates a fresh Russian residential IP per request to survive the `ozon-antibot` challenge.
- ⚡ **No browser, no key** — pure HTTP against Ozon's widget API; every item carries `_mode` and `scrapedAt` (ISO 8601).
#### The 3 modes
| Mode | What it returns |
|---|---|
| `search` | Products matching a keyword, paginated (highest volume, default) |
| `category` | Every product in an Ozon category, paginated by slug/URL |
| `product` | Full detail for one or more product URLs/IDs (best-effort — see FAQ) |
### 🚀 Quick start (3 steps)
1. **Pick a Mode** — start with `search` and a keyword to build a product dataset, or use `category` with a category slug to crawl a whole section.
2. **Fill the fields that mode needs** — a `query` for search (e.g. `iphone`), or a `category` slug like `smartfony-15502`. Leave everything blank to browse a popular default.
3. **Run & export** — download results as **JSON, CSV, Excel, HTML, RSS or JSON Lines**, or pull them via the Apify API.
### 📥 Input
Pick a `mode`, then fill only the fields that mode needs.
#### Example — search for iPhones (600 products)
```json
{
"mode": "search",
"query": "iphone",
"sort": "relevance",
"maxResults": 600
}
````
#### Example — crawl the Smartphones category
```json
{
"mode": "category",
"category": "smartfony-15502",
"maxResults": 2000
}
```
#### Example — cheapest headphones first
```json
{
"mode": "search",
"query": "наушники",
"sort": "price_asc",
"maxResults": 500
}
```
| Field | Type | Used by | Default | Description |
|-------|------|---------|---------|-------------|
| `mode` | string | all | `search` | `search`, `category` or `product`. |
| `query` | string | search | `iphone` | Free-text keyword (Russian or English). Empty → popular default. |
| `sort` | string | search | `relevance` | `relevance`, `price_asc`, `price_desc`, `rating`, `new`, `discount`. |
| `category` | string | category | — | Ozon category slug (`smartfony-15502`), path or full URL. |
| `productUrls` | array | product | `[]` | Ozon product URLs or numeric IDs (batch). |
| `maxResults` | integer | all | `500` | Row cap; drives pagination for search & category. |
| `proxyCountry` | string | all | `RU` | Residential exit country — must be `RU` (Ozon is Russia-only). |
### 📤 Output
Results stream to the dataset; every item carries `_mode` and `scrapedAt`. Here is a real **product** row from a `search` run:
```json
{
"_mode": "search",
"productId": 1181913217,
"sku": "1181913217",
"name": "Apple Смартфон iPhone 15 128 ГБ, чёрный (Black)",
"brand": null,
"url": "https://www.ozon.ru/product/apple-smartfon-iphone-15-128-gb-chernyy-black-1181913217/",
"price": 62990,
"originalPrice": 89990,
"cardPrice": 61200,
"discountPercent": 30,
"currency": "RUB",
"rating": 4.9,
"reviewCount": 875,
"isAvailable": true,
"stockText": "1 шт осталось",
"deliveryDate": "Завтра",
"badges": ["Apple", "Оригинал"],
"images": [
"https://ir.ozone.ru/s3/multimedia-1-l/7669840197.jpg",
"https://ir.ozone.ru/s3/multimedia-1-6/7669840218.jpg"
],
"isAdult": false,
"query": "iphone",
"scrapedAt": "2026-07-24T09:00:00.000Z"
}
```
📋 Full field reference (click to expand)
**Search / Category tiles** (`search`, `category`):
| Field | Type | Description |
|---|---|---|
| `productId` | number | Ozon SKU as a number (unique product identifier) |
| `sku` | string | Same SKU as a string |
| `name` | string | Product title |
| `url` | string | Canonical product URL (tracking stripped) |
| `price` | number | Current selling price in ₽ |
| `originalPrice` | number | Strike-through / “was” price in ₽ |
| `cardPrice` | number | Discounted price with an Ozon Card in ₽ |
| `discountPercent` | number | Discount percentage (derived if not given) |
| `currency` | string | Always `RUB` |
| `rating` | number | Average customer rating (0–5) |
| `reviewCount` | number | Number of reviews |
| `isAvailable` | boolean | Whether the product is purchasable |
| `stockText` | string | Human-readable stock note (e.g. “1 шт осталось”) |
| `deliveryDate` | string | Earliest delivery label (e.g. “Завтра”, “27 июля”) |
| `badges` | array | Seller / quality labels (brand, “Оригинал”, …) |
| `images` | array | Product image URLs |
| `isAdult` | boolean | Adult-content flag |
**Product mode** (`product`) additionally attempts: `brand`, `category`, `breadcrumbs[]`, `specifications[]` (key/value), `variants[]` (skuId/title/available), `priceHistory[]` ({date,price}), `sellerList[]` (name/price).
**Universal** (every row): `_mode`, `scrapedAt` (ISO 8601).
### 💡 Use cases
- **Price monitoring & repricing** — track competitor prices, discounts and Ozon-Card prices across a category on a schedule, and feed a repricing engine or alerting workflow.
- **E-commerce & market analytics** — build a product dataset filtered by keyword or category and chart price distributions, discount depth, rating vs. review-count in a BI tool.
- **Competitor & assortment research** — see who sells what, at what price, with which badges, and how a category's catalogue is structured.
- **Catalog enrichment** — enrich your own listings with Ozon prices, ratings, images and stock signals for the Russian market.
- **Demand & review mining** — use `rating` and `reviewCount` as proxies for popularity and demand, or shortlist high-review products for deeper study.
- **AI agents & RAG** — wrap the Actor as a tool so an LLM can answer “what are the cheapest 4.8★+ robot vacuums on Ozon right now?”
### 👥 Who uses it
E-commerce and pricing analysts · marketplace sellers benchmarking competitors · market-research and consulting teams · data engineers building product datasets · repricing / monitoring tools · AI-agent builders wiring Ozon as a data source.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** model — you pay for the product rows you extract, with no separate Apify platform fees to calculate. Results are de-duplicated, so you don't pay twice for the same product. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### 🛠️ How it works (engine)
Ozon renders its storefront from a **widget JSON API** (`composer-api.bx`). This Actor calls that API directly:
1. **ETC handshake** — the first request returns `307` + a `__Secure-ETC` cookie; the Actor follows the redirect (`&__rr=1`) keeping a per-request cookie jar until it reaches the `200` JSON payload.
2. **Search → category resolution** — a keyword search self-redirects (`302`) into the matching category page, carrying a `search_page_state` token that unlocks pagination.
3. **Widget parsing** — the response's `widgetStates` map holds double-encoded JSON strings; the Actor parses the product-tile widget (`tileGridDesktop` / `searchResultsV2`) and decodes each tile's typed “atoms” (price, name, rating, badges, images).
4. **Deep pagination** — it walks the `infiniteVirtualPaginator` by incrementing `page` / `layout_page_index` and re-calling the composer with `page_changed=true`, using a small concurrency pool and de-duplicating by `productId`.
5. **Anti-block** — every request goes through Apify **RESIDENTIAL** proxy pinned to **country RU** (Ozon geo-blocks non-Russian IPs), rotating a fresh IP + fresh session per request to ride out the `ozon-antibot` challenge; a ~4-minute time budget then pushes everything collected and exits successfully.
### 💡 Tips for best results
- **Keep `proxyCountry` = RU.** Ozon only answers Russian IPs; any other exit country will be blocked.
- **Use `category` for volume.** Category crawls have hundreds of pages; a single keyword search resolves to a narrower slice.
- **Raise `maxResults` for big pulls** and lower it for a fast, cheap sample. The empty-input default is deliberately modest.
- **Find category slugs in the URL.** On any Ozon category page the address bar shows `.../category//` — paste the slug or the whole URL.
- **Combine several keyword runs** (e.g. schedule `iphone`, `samsung`, `xiaomi`) to assemble a broad multi-brand dataset.
- **Prices are numbers**, so you can sort, filter and aggregate straight away in Sheets, Excel or SQL.
- **Re-run if a run comes back light** — Ozon occasionally throttles; the Actor rotates fresh RU IPs automatically, so a repeat run usually fills in.
- **Schedule it** for daily/weekly price snapshots and diff the datasets to detect price changes.
### 🔌 Integrations
Connect this Actor to the rest of your stack with a few clicks:
- **Google Sheets** — push results into a spreadsheet for price dashboards.
- **Slack / email** — get notified when a run finishes or a price crosses a threshold (via webhooks + Make/Zapier).
- **Zapier & Make (Integromat)** — no-code automation: trigger on new dataset items and route them anywhere.
- **Webhooks** — POST run + dataset events to your own endpoint.
- **Apify Scheduler** — run hourly/daily/weekly to build a price time-series.
- **Databases & BI** — export CSV/JSON/Excel or pull via API into Postgres, BigQuery, Power BI, etc.
### 🧩 API usage
Run the Actor and fetch results via the Apify API (get your token from **Settings → Integrations**).
**cURL**
```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~ozon-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "mode": "search", "query": "iphone", "maxResults": 500 }'
```
**Node.js (apify-client)**
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/ozon-scraper').call({
mode: 'category',
category: 'smartfony-15502',
maxResults: 2000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'products');
```
**Python (apify-client)**
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/ozon-scraper").call(run_input={
"mode": "search",
"query": "наушники",
"sort": "price_asc",
"maxResults": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["name"], item["price"])
```
### 🤖 Use with AI agents (MCP)
This Actor works great as a tool for LLM agents through the Apify MCP server: expose it to your agent and let the model call it with a keyword or category to fetch live Ozon prices and ratings, then reason over the JSON. Example prompt: *“Use the Ozon scraper to get the 20 cheapest robot vacuums rated 4.5★ or higher and summarize the price range.”*
### ❓ Frequently Asked Questions
#### Do I need an Ozon API key or account?
No. This is an unofficial Ozon scraper that reads publicly available data through Ozon's own web endpoints. You only need an Apify account — no Ozon API key, no login, no cookies to supply.
#### Why does it need a Russian proxy?
Ozon.ru only serves requests from Russian IP addresses and challenges everything else. The Actor routes traffic through Apify's **RESIDENTIAL** proxy pinned to **RU** and handles the anti-bot handshake for you. This is built in — you don't configure anything beyond leaving `proxyCountry` as `RU`.
#### How many products can one run return?
Hundreds to thousands. A keyword search paginates its resolved result set; a **category** crawl walks the full catalogue (often 100+ pages). Results are de-duplicated by product ID, and pagination stops at your `maxResults` or a ~4-minute time budget.
#### How do I scrape a whole Ozon category?
Use `mode: "category"` and pass the category slug (e.g. `smartfony-15502`), a path (`/category/smartfony-15502/`) or the full category URL. You can find the slug in the address bar on any Ozon category page.
#### Can I scrape Ozon prices and discounts?
Yes — every product row includes `price`, `originalPrice`, `cardPrice` (the Ozon-Card price) and `discountPercent`, all as real numbers in rubles, so you can monitor and compare prices directly.
#### Does it get ratings and review counts?
Yes. Product tiles that display them include `rating` (e.g. `4.9`) and `reviewCount`. Tiles without a rating (some ads/new items) return `null` for those fields.
#### Why are some fields null?
Not every tile exposes every attribute — sponsored placements and brand-new listings may lack a rating, review count or stock note. Rows are never all-null; core fields (id, name, url, price) are populated whenever Ozon provides them.
#### What about full product detail (specs, sellers, price history)?
The `product` mode targets Ozon's product page, which is **strongly anti-bot protected** — it may be blocked even with residential IPs and is provided on a **best-effort** basis. For reliable price/rating/review data at scale, use `search` or `category` mode, where the tile data already includes price, discount, rating, review count, images and badges.
#### How do I export the data to CSV, JSON or Excel?
Run any mode and download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSON Lines from the run page, or pull it via the Apify API. This makes it a simple Ozon data-export and price-dataset tool.
#### How often is the data updated?
It's live — every run fetches current data straight from Ozon. Schedule the Actor hourly, daily or weekly to build a price and rating time-series.
#### Is it an Ozon API or an API alternative?
Both, effectively. It works as an unofficial **Ozon API** and a practical **Ozon dataset API alternative**: send structured input, get structured JSON back, without any official Ozon data licence.
#### Is it legal to scrape Ozon?
The Actor collects only publicly available data served by Ozon's own endpoints, for legitimate research, analytics and price-monitoring use. You are responsible for using the data in compliance with Ozon's terms of service and applicable laws.
### ⚖️ Is it legal?
This Actor extracts only **publicly available** product data that Ozon serves to any visitor, and is intended for legitimate price monitoring, market research, analytics and dataset-building. It does not access private accounts, personal data or anything behind a login. You are responsible for complying with Ozon's Terms of Service, robots directives and any applicable local laws and data-protection regulations (including how you store and use the collected data).
### 🔗 Related scrapers by logiover
Building a marketplace or e-commerce dataset? Pair Ozon with the rest of the suite:
| Actor | What it does |
|---|---|
| [Wildberries Scraper](https://apify.com/logiover/wildberries-scraper) | Products, prices and ratings from Wildberries (RU) |
| [Mercari Japan Scraper](https://apify.com/logiover/mercari-jp-scraper) | Listings and prices from Mercari Japan |
| [Lazada Scraper](https://apify.com/logiover/lazada-scraper) | Products and prices from Lazada (SEA) |
| [Amazon Product Scraper](https://apify.com/logiover) | Product data, prices and reviews from Amazon |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across e-commerce, real estate, jobs, crypto, social media & B2B data.
### ⭐ Support & feedback
Found a bug or need an extra field or mode? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
***
### 📝 Changelog
#### 2026-07-24
- Initial release: Ozon Scraper v1.0 with `search`, `category` and best-effort `product` modes over Ozon's public widget API — no key, no browser. Deep, de-duplicated pagination behind a Russian residential proxy with automatic anti-bot handling.
# Actor input Schema
## `mode` (type: `string`):
What to scrape on Ozon.ru.
• **search** — search products by keyword and paginate the result set (highest volume, default)
• **category** — crawl a whole Ozon category by its slug/URL
• **product** — fetch full detail for one or more product URLs/IDs (best-effort; Ozon product pages are anti-bot heavy)
## `query` (type: `string`):
Free-text search term for **search** mode — a product name, brand or phrase in Russian or English (e.g. `iphone`, `наушники`, `робот пылесос`). Leave empty to browse a popular default.
## `sort` (type: `string`):
How to order search results.
## `category` (type: `string`):
For **category** mode: an Ozon category slug (e.g. `smartfony-15502`), a category path (`/category/smartfony-15502/`) or a full Ozon category URL. Find it in the address bar on any Ozon category page.
## `productUrls` (type: `array`):
For **product** mode: one or more Ozon product URLs (`https://www.ozon.ru/product/...`) or numeric product IDs. Note: Ozon product pages are strongly anti-bot protected; this mode is best-effort. For price/rating/reviews at scale, prefer search or category mode.
## `maxResults` (type: `integer`):
Upper bound on the number of product rows to return. Drives pagination for search and category modes. Raise it to pull thousands; keep it modest for a fast, cheap run.
## `proxyCountry` (type: `string`):
Residential proxy exit country. Ozon.ru only serves Russian IPs, so this must be Russia (RU). Exposed only for transparency — leave as Russia.
## Actor input object example
```json
{
"mode": "search",
"query": "iphone",
"sort": "relevance",
"category": "smartfony-15502",
"productUrls": [],
"maxResults": 500,
"proxyCountry": "RU"
}
```
# Actor output Schema
## `results` (type: `string`):
Full results dataset — Ozon products with prices, discounts, ratings and images.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "search",
"query": "iphone",
"category": "smartfony-15502",
"productUrls": [],
"maxResults": 500
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/ozon-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "search",
"query": "iphone",
"category": "smartfony-15502",
"productUrls": [],
"maxResults": 500,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/ozon-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"mode": "search",
"query": "iphone",
"category": "smartfony-15502",
"productUrls": [],
"maxResults": 500
}' |
apify call logiover/ozon-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/ozon-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Ozon Scraper — Products, Prices, Specs, Reviews & Sellers",
"description": "Scrape Ozon.ru by keyword or category. Extract product name, price, discount, rating, review count, images, badges and stock at scale. No API key, no login. For price monitoring, e-commerce analytics and market research.",
"version": "1.0",
"x-build-id": "z801bmMJryqEvYGQI"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~ozon-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-ozon-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/logiover~ozon-scraper/runs": {
"post": {
"operationId": "runs-sync-logiover-ozon-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/logiover~ozon-scraper/run-sync": {
"post": {
"operationId": "run-sync-logiover-ozon-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"properties": {
"mode": {
"title": "Mode",
"enum": [
"search",
"category",
"product"
],
"type": "string",
"description": "What to scrape on Ozon.ru.\n\n• **search** — search products by keyword and paginate the result set (highest volume, default)\n• **category** — crawl a whole Ozon category by its slug/URL\n• **product** — fetch full detail for one or more product URLs/IDs (best-effort; Ozon product pages are anti-bot heavy)",
"default": "search"
},
"query": {
"title": "Search keyword",
"type": "string",
"description": "Free-text search term for **search** mode — a product name, brand or phrase in Russian or English (e.g. `iphone`, `наушники`, `робот пылесос`). Leave empty to browse a popular default."
},
"sort": {
"title": "Sort order",
"enum": [
"relevance",
"price_asc",
"price_desc",
"rating",
"new",
"discount"
],
"type": "string",
"description": "How to order search results.",
"default": "relevance"
},
"category": {
"title": "Category slug or URL",
"type": "string",
"description": "For **category** mode: an Ozon category slug (e.g. `smartfony-15502`), a category path (`/category/smartfony-15502/`) or a full Ozon category URL. Find it in the address bar on any Ozon category page."
},
"productUrls": {
"title": "Product URLs or IDs (batch)",
"type": "array",
"description": "For **product** mode: one or more Ozon product URLs (`https://www.ozon.ru/product/...`) or numeric product IDs. Note: Ozon product pages are strongly anti-bot protected; this mode is best-effort. For price/rating/reviews at scale, prefer search or category mode.",
"items": {
"type": "string"
},
"default": []
},
"maxResults": {
"title": "Max results",
"minimum": 1,
"maximum": 100000,
"type": "integer",
"description": "Upper bound on the number of product rows to return. Drives pagination for search and category modes. Raise it to pull thousands; keep it modest for a fast, cheap run.",
"default": 500
},
"proxyCountry": {
"title": "Proxy country",
"enum": [
"RU"
],
"type": "string",
"description": "Residential proxy exit country. Ozon.ru only serves Russian IPs, so this must be Russia (RU). Exposed only for transparency — leave as Russia.",
"default": "RU"
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```