# 4lapy Scraper (`sashaebashu/4lapy-scraper`) Actor

Scrape the Four Paws / Четыре лапы (4lapy.ru) pet catalog by category — name, price, discount, stock quantity, rating and reviews. Fast JSON API, runs on cheap datacenter proxy.

- **URL**: https://apify.com/sashaebashu/4lapy-scraper.md
- **Developed by:** [Sasha Ebashu](https://apify.com/sashaebashu) (community)
- **Categories:** Automation, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Four Paws (4lapy) Pet Store Scraper

Scrape the **Four Paws / Четыре лапы** (`4lapy.ru`) pet catalog by category and get clean, structured data for every product — **name, price, old price, discount, stock quantity, rating and review count** — straight from the store's own JSON API.

No login, no API key. Fast, cheap (runs on **datacenter** proxy), and stable. Export to **JSON, CSV, Excel or Google Sheets**.

---

### What it extracts

For every product in a category:

- 🏷️ **Name** and **brand**
- 💰 **Price** (₽), **old price** and **discount %** when on sale
- 📦 **Stock quantity** — the real available count (`stock`) plus an **availability** flag — most pet scrapers can't get this
- ⭐ **Rating** and **review count**
- 🔗 **Product URL**, **product / offer IDs**, **article** and **image**
- 🗂️ The **category** it came from and a **scrapedAt** timestamp

Run it on a schedule and diff the results to watch competitor prices **and stock** move.

---

### How to use it

Three ways to point it at products — use any or all:

**Track specific products** (price monitoring):
- Paste **product URLs** (e.g. `https://4lapy.ru/product/royal-canin-sterilised-37-2kg-3139109-1015911/`). You get the current price, discount, **stock** and rating for exactly those products — ideal for watching your own or competitors' SKUs over time on a schedule.

**Search by keyword** (the quick way):
- Add **search queries** like `корм`, `Royal Canin Sterilised`, `наполнитель`. You get the top matching products (with price, stock and rating) for each query — perfect for "what does 4lapy charge for X".

**Scrape whole categories** (the full listing):
1. Add one or more **category URLs** (or just their slugs):
   - Full URL: `https://4lapy.ru/catalog/koshki/`
   - Slug only: `koshki`
   - Top-level slugs: `koshki` (cats), `sobaki` (dogs), `gryzuny-i-khorki`, `ptitsy`, `reptilii`, `ryby`, `veterinarnaya-apteka`. Subcategory URLs work too.
2. Pick a **sort order** (popular / price low-to-high / price high-to-low).
3. Set **max pages per category** (50 products per page) and an optional total **max items** cap.

Then run it and download or pull the results via API.

---

### Monitor mode (track changes between runs)

Turn on **`monitorMode`** and run the actor on a schedule: it compares each run to the previous one (per the same input) and tags every product with **what changed** — so you catch competitor moves instead of re-reading a full dump each time. Each row gains:

- `changeType` — `new`, `price_up`, `price_down`, `stock_change` or `unchanged`
- `previousPrice` — the price at the last run
- `priceLow30` / `priceHigh30` — rolling 30-day low and high (spot fake discounts / MAP breaks)
- `firstSeenAt` / `lastConfirmedAt` — when the product first appeared and was last confirmed

Add **`onlyChanges`** to output just the products that moved — a clean delta you can pipe into alerts or a spreadsheet. Monitor mode is off by default, so normal runs are unaffected.

### Cost & proxy

The 4lapy catalog is served by a public JSON API that works over **Apify's datacenter proxy** (the default) — so this scraper is **cheap and fast**, no residential proxy required. Apify's **$5/month free credits** go a long way here.

---

### Input parameters

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `productUrls` | array | Specific 4lapy product URLs to track (current price, stock, rating) | — |
| `monitorMode` | boolean | Compare to the previous run and tag each product with what changed (+ 30-day low/high, first-seen date) | `false` |
| `onlyChanges` | boolean | With monitor mode on, output only the products that changed | `false` |
| `searchQueries` | array | Keywords / product names to search (top matches returned per query) | — |
| `categoryUrls` | array | Category page URLs or slugs to scrape in full | one example category |
| `sort` | string | `popular`, `price_asc` or `price_desc` | `popular` |
| `maxPagesPerCategory` | integer | API pages per category (100 items each); 0 = until the category ends | 10 |
| `maxItems` | integer | Stop after this many products in total (0 = unlimited) | 0 |
| `proxyConfiguration` | object | Proxy — Apify datacenter is enough | datacenter |

---

### Output fields

| Field | Description |
|---|---|
| `store` | Always `"4lapy"`. |
| `productId` / `offerId` | 4lapy product and offer IDs. |
| `article` | Vendor article number. |
| `name` | Product name. |
| `brand` | Brand code. |
| `price` | Current price, ₽. |
| `oldPrice` | Pre-discount price, ₽, when on sale (else `null`). |
| `discountPct` | Discount percentage when on sale (else `null`). |
| `currency` | Always `"RUB"`. |
| `available` | Whether the product is available. |
| `stock` | Available stock quantity. |
| `rating` | Average rating (else `null`). |
| `reviewsCount` | Number of reviews. |
| `image` | Product image URL. |
| `url` | Direct link to the product page. |
| `changeType`, `previousPrice`, `priceLow30`, `priceHigh30`, `firstSeenAt`, `lastConfirmedAt` | Present only in **monitor mode** — see above. |
| `query` | The search query that matched this row (empty for category rows). |
| `categorySlug` / `categoryId` | The category the product was scraped from (empty for search rows). |
| `scrapedAt` | Timestamp of the run. |

---

### Notes

- Only public catalog data is collected. Respect 4lapy's Terms of Service and your local regulations.
- Prices and stock reflect the default region (Moscow / all-Russia availability).

# Actor input Schema

## `productUrls` (type: `array`):

Paste 4lapy.ru product page URLs to track exactly those products — you get their current price, discount, stock and rating. Great for monitoring your own or competitors' SKUs over time. Example: https://4lapy.ru/product/royal-canin-sterilised-37-2kg-3139109-1015911/
## `searchQueries` (type: `array`):

Search 4lapy by keyword or product name, e.g. "корм", "Royal Canin Sterilised", "наполнитель". Returns the top matching products (name, price, stock, rating) for each query. Use categories below if you want the full listing of a section.
## `categoryUrls` (type: `array`):

4lapy.ru category pages to scrape in full. Paste full URLs like https://4lapy.ru/catalog/koshki/ or just the category slug (koshki). Top-level slugs: koshki, sobaki, gryzuny-i-khorki, ptitsy, reptilii, ryby, veterinarnaya-apteka. Subcategory URLs work too.
## `sort` (type: `string`):

Product sort order used when paging a category.
## `maxPagesPerCategory` (type: `integer`):

How many API pages (100 products each) to fetch per category. 0 = until the category ends.
## `maxItems` (type: `integer`):

Stop after this many products in total (0 = unlimited).
## `monitorMode` (type: `boolean`):

Compare this run to the previous one (per the same input). Each product gets changeType (new / price_up / price_down / stock_change / unchanged), previousPrice, firstSeenAt / lastConfirmedAt, and a rolling 30-day price low/high. Turns the scraper into a price & stock monitor you run on a schedule.
## `onlyChanges` (type: `boolean`):

With monitor mode on, output only the products that changed since the last run (skip unchanged ones) — a clean delta for your monitor.
## `proxyConfiguration` (type: `object`):

The 4lapy API works over Apify's datacenter proxy (cheap), which is the default. Residential is not required.

## Actor input object example

```json
{
  "productUrls": [],
  "searchQueries": [],
  "categoryUrls": [
    "https://4lapy.ru/catalog/koshki/"
  ],
  "sort": "popular",
  "maxPagesPerCategory": 10,
  "maxItems": 0,
  "monitorMode": false,
  "onlyChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

# Actor output Schema

## `overview` (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 = {
    "productUrls": [],
    "searchQueries": [],
    "categoryUrls": [
        "https://4lapy.ru/catalog/koshki/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sashaebashu/4lapy-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 = {
    "productUrls": [],
    "searchQueries": [],
    "categoryUrls": ["https://4lapy.ru/catalog/koshki/"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("sashaebashu/4lapy-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 '{
  "productUrls": [],
  "searchQueries": [],
  "categoryUrls": [
    "https://4lapy.ru/catalog/koshki/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call sashaebashu/4lapy-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sashaebashu/4lapy-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "4lapy Scraper",
        "description": "Scrape the Four Paws / Четыре лапы (4lapy.ru) pet catalog by category — name, price, discount, stock quantity, rating and reviews. Fast JSON API, runs on cheap datacenter proxy.",
        "version": "0.2",
        "x-build-id": "sH1AYE3fRQFdMhN9j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sashaebashu~4lapy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sashaebashu-4lapy-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/sashaebashu~4lapy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sashaebashu-4lapy-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/sashaebashu~4lapy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sashaebashu-4lapy-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": {
                    "productUrls": {
                        "title": "Product URLs (track specific products)",
                        "type": "array",
                        "description": "Paste 4lapy.ru product page URLs to track exactly those products — you get their current price, discount, stock and rating. Great for monitoring your own or competitors' SKUs over time. Example: https://4lapy.ru/product/royal-canin-sterilised-37-2kg-3139109-1015911/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search 4lapy by keyword or product name, e.g. \"корм\", \"Royal Canin Sterilised\", \"наполнитель\". Returns the top matching products (name, price, stock, rating) for each query. Use categories below if you want the full listing of a section.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "Category URLs or slugs",
                        "type": "array",
                        "description": "4lapy.ru category pages to scrape in full. Paste full URLs like https://4lapy.ru/catalog/koshki/ or just the category slug (koshki). Top-level slugs: koshki, sobaki, gryzuny-i-khorki, ptitsy, reptilii, ryby, veterinarnaya-apteka. Subcategory URLs work too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "popular",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Product sort order used when paging a category.",
                        "default": "popular"
                    },
                    "maxPagesPerCategory": {
                        "title": "Max pages per category",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many API pages (100 products each) to fetch per category. 0 = until the category ends.",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Max output rows",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many products in total (0 = unlimited).",
                        "default": 0
                    },
                    "monitorMode": {
                        "title": "Monitor mode (track changes between runs)",
                        "type": "boolean",
                        "description": "Compare this run to the previous one (per the same input). Each product gets changeType (new / price_up / price_down / stock_change / unchanged), previousPrice, firstSeenAt / lastConfirmedAt, and a rolling 30-day price low/high. Turns the scraper into a price & stock monitor you run on a schedule.",
                        "default": false
                    },
                    "onlyChanges": {
                        "title": "Return only changed products",
                        "type": "boolean",
                        "description": "With monitor mode on, output only the products that changed since the last run (skip unchanged ones) — a clean delta for your monitor.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "The 4lapy API works over Apify's datacenter proxy (cheap), which is the default. Residential is not required."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
