# Altex.ro Product Scraper: Prices, Stock, Specs & Reviews (`extractify-labs/altex-ro-scraper`) Actor

Scrape altex.ro products by category, search, product link, SKUs or the whole catalogue. Get prices and promotions, open-box deals, stock per store, sellers, specifications, ratings and reviews: up to 103 fields per product. Filter by brand, price and stock. Unofficial, not affiliated with Altex.

- **URL**: https://apify.com/extractify-labs/altex-ro-scraper.md
- **Developed by:** [Extractify Labs](https://apify.com/extractify-labs) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 3 total users, 3 monthly users, 98.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.25 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Altex.ro Product Scraper: Prices, Stock, Specs & Reviews

> Unofficial tool. Not affiliated with, endorsed by, or sponsored by Altex Romania or altex.ro.

Altex.ro Product Scraper collects product data from altex.ro, one of Romania's largest electronics
and home-appliance shops: prices and promotions, open-box (resigilate) deals, stock in each store,
sellers, specifications, ratings and reviews. You get up to 103 fields per product and pay only
for the products you receive.

### 🇷🇴 Pe scurt, în română

Extrage date despre produsele de pe altex.ro: prețuri și promoții, produse resigilate, stoc în
magazine, vânzători, specificații, note și recenzii. Pornești de la o categorie, o căutare, un
link de produs, o listă de coduri SKU sau tot catalogul, și folosești aceleași filtre ca pe site
(brand, preț, stoc, promoții). Ideal pentru monitorizarea prețurilor Altex, analiza concurenței
și studii de piață. Plătești doar pentru produsele primite. Instrument neoficial, fără legătură
cu Altex Romania.

### ✅ What it does

- 💸 **Track prices and promotions.** Current price, previous (struck-through) price, recommended
  price, discount type and amount, the "SUPER PRET" flag, monthly instalments and promo badges.
- 📦 **See what is in stock, and where.** Normalised availability next to the site's raw stock
  code, pre-orders with release dates, store pickup, locker delivery, and optionally the stock
  in each Altex store.
- 🏷️ **Find open-box deals.** How many resigilate units a product has and the price of the
  cheapest one. With product details on, every open-box unit with its price, defect notes and
  store.
- 🛒 **Watch the marketplace.** The seller in the buy box, whether it is Altex or a marketplace
  seller, and with product details on, every seller's offer.
- 🔍 **Build a product catalogue.** EAN codes, MPN, brand, category path, the full image gallery,
  grouped specifications, descriptions, warranty and the EU manufacturer details.
- ⭐ **Read what buyers say.** Rating, review count and star breakdown, plus review texts, review
  photos and questions and answers when you switch them on.

### 🚀 Quick start

Run it as it is. The default input collects **50 phones** from the altex.ro phones category in a
few seconds, with no proxy:

```
{
  "startUrls": [{ "url": "https://altex.ro/telefoane/cpl/" }],
  "maxItems": 50
}
```

An empty input `{}` runs exactly the same job.

A filtered example, the cheapest in-stock Samsung phones (up to 200), with full product details:

```
{
  "startUrls": [{ "url": "https://altex.ro/telefoane/cpl/" }],
  "brands": ["Samsung"],
  "availability": "in_stock",
  "sortBy": "price_asc",
  "maxItems": 200,
  "includeProductDetails": true
}
```

### 🔧 Input

**What to scrape.** Use any mix of these in one run:

| Input | What it takes |
|---|---|
| Start URLs | altex.ro category links (`…/cpl/`, including filtered ones), search links (`…/cauta/?q=…`) and product links (`…/cpd/<SKU>/`). The type is detected for you. |
| Search terms | Words to search for, as you would type them on altex.ro (at least 3 characters). |
| SKUs | Altex product codes, for example from your own list or an earlier run. |
| Whole catalogue | Every product on altex.ro. Other sources and filters are ignored when this is on. |
| Max products | How many products to collect in total. 0 means no limit. |

**Filters** (for categories and searches): brands, minimum and maximum price in RON, availability
(in stock, in stock at the supplier, pre-order), promotions and SUPER PRET, minimum rating, new
arrivals, products with open-box units, sold by Altex only, sellers (by seller ID), in stock at
chosen Altex stores (by store ID), and sorting (recommended, price, name, best deal, most
reviewed). Sold by Altex only, Sellers and In stock at stores work on categories only.

**Extra data** (each adds run time, never cost per product): product details, stock per store,
delivery options for a city, reviews, questions and answers, and product-page extras (return
window and item condition).

**Connection:** no proxy by default. You can switch on Apify Proxy (datacenter) if your runs are
refused.

### 📊 Output

One row per product (SKU). Every row has the same 106 fields, so exports never shift columns. A
field the site does not show, or that belongs to an extra you did not switch on, is `null`. Prices
are in RON, VAT included, and the `currency` field says so. Every row also records when it was
scraped (`scrapedAt`), how it was found (`source`: category, search, sku or catalogue) and from
which link, term or SKU (`sourceInput`).

A default run fills about 51 fields per product. Switching on product details fills about 41 more,
and the other extras fill the rest.

A shortened example row (illustrative values):

```
{
  "sku": "EXAMPLE123",
  "name": "Telefon mobil EXAMPLE X, 128GB, 8GB RAM, Negru",
  "brand": "EXAMPLE",
  "price": 1499.99,
  "regularPrice": 1799.99,
  "discountAmount": 300,
  "currency": "RON",
  "availability": "in_stock",
  "resealedCount": 2,
  "resealedMinPrice": 1289.99,
  "rating": 4.67,
  "reviewsCount": 15,
  "sellerName": "Altex",
  "isMarketplace": false,
  "url": "https://altex.ro/telefon-example-x/cpd/EXAMPLE123/",
  "scrapedAt": "2026-10-23T09:00:00Z",
  "source": "category",
  "sourceInput": "https://altex.ro/telefoane/cpl/"
}
```

The results come with ready-made table views: **Products**, **Prices and promotions**, **Stock
and delivery**, **Product details**, **Sellers and offers**, **Ratings, reviews and Q\&A**, and
**All fields**.

#### Fields

| Group | Fields | Filled |
|---|---|---|
| Identity | `sku`, `productId`, `name`, `urlKey`, `url`, `brand`, `brandId`, `eanCodes`, `attributeSetId`, `productType`, `familyId`, `visibility`, `status` | every run |
| Brand and codes | `brandLogoUrl`, `brandPageUrl`, `mpn`, `color` | product details |
| Prices | `price`, `regularPrice`, `msrpPrice`, `discountType`, `discountAmount`, `isSuperPrice`, `currency`, `installmentsPrice`, `priceUnit`, `priceFactor` | every run |
| More prices | `greenTax`, `packageSellingPrice`, `packageBasePrice` | product details |
| Stock | `stockStatus`, `availability`, `stockType`, `pickupInStock`, `isPreorder`, `preorderReleaseDate`, `isOnDemand`, `isEol`, `eolStatus`, `lockerEligible`, `inBundle`, `stockStoreIds`, `stockStoreCount` | every run |
| Stock in stores | `availableInStore` (product details), `storeAvailability` (stock per store as JSON text, with each store's `manager_name` and `phone`) | extras |
| Sellers | `sellerName`, `sellerId`, `isMarketplace`, `sellerIds` | every run |
| Offers | `sellerUrlKey`, `offers`, `offersCount` | product details |
| Category | `breadcrumbs`, `categoryName`, `categoryId`, `categoryUrl`, `categoryPath` | product details |
| Images | `imageUrl`, `thumbnailUrl` (every run), `images`, `imageCount` (product details) | |
| Energy label | `energyClass`, `energyLabelUrl` | every run |
| Descriptions | `shortDescription` (every run), `description`, `descriptionHtml`, `descriptionText`, `descriptionImages`, `hasExternalRichContent`, `seoTitle`, `metaTitle`, `metaDescription`, `metaRobots` (product details) | |
| Specifications | `specifications` (grouped), `specificationsMap` (flat, as JSON text) | product details |
| Warranty and manufacturer | `warrantyConsumer`, `warrantyBusiness`, `manufacturerName`, `manufacturerAddress`, `manufacturerContact` | product details |
| Variants | `variantOptions`, `variantSkus` | every run |
| Open box | `resealedCount`, `resealedMinPrice` (every run), `resealedOffers` (product details) | |
| Add-on services | `extraWarrantyOptions`, `insuranceOptions`, `installationServices` | product details |
| Ratings | `rating`, `reviewsCount`, `ratingStarsSum` (every run), `ratingDistribution`, `recommendPercent`, `questionsCount` (product details) | |
| Reviews and Q\&A | `reviews` (JSON text), `reviewImageUrls`, `questions` (JSON text) | reviews / questions |
| Promotions | `hasGift`, `labels` | every run |
| Delivery | `shippingOptions`, `freeShippingPromo` | delivery options |
| Product page | `returnDays`, `itemCondition` | product-page extras |
| Run | `scrapedAt`, `source`, `sourceInput` | every run |

**Good to know about a few fields:**

- `rating` is the exact average out of 5 (the site's own display rounds it to one decimal).
- `resealedMinPrice` is the price of the cheapest open-box (resigilat) unit on offer. It is
  `null` when there are none. It is not a 30-day lowest price: altex.ro does not publish one.
- `availability` is one of `in_stock`, `out_of_stock` or `preorder`. `stockStatus` keeps the
  site's own code next to it.
- `packageSellingPrice` and `packageBasePrice` are filled when altex.ro shows a package price for
  unit-priced goods. Today the site leaves them empty on every product, so they come as `null`.
- `isEol`, `inBundle`, `hasGift` and `freeShippingPromo` turn `true` when altex.ro marks a product
  as discontinued, part of a bundle, with a gift or with a free-delivery promotion. Today the site
  marks none, so they come as `false`.
- `storeAvailability`, `specificationsMap`, `reviews` and `questions` are JSON text, so that CSV
  and Excel exports stay at one column each and wide runs keep every column. Parse them with any
  JSON parser (`JSON.parse` in JavaScript, `json.loads` in Python). `stockStoreIds` stays a plain
  list of store ids.

### 💸 Pricing

You pay only for products delivered: **$2.50 per 1,000 products** on the Apify Free
plan, with automatic discounts on paid Apify plans (from $2.25 per 1,000). The price is
the same whatever extras you switch on, and there are no proxy fees or usage charges on top.

Set a spending limit on the run and the actor stops cleanly when it is reached, keeping
everything it has collected. A run that is refused by the site ends as failed and costs nothing
for products.

### ⚡ Speed

| Job | Time per 1,000 products |
|---|---|
| Categories, searches or SKUs, list only (the default) | seconds |
| With product details | about 10 minutes |
| With every extra switched on | about 45 to 50 minutes |

The whole catalogue (more than 590,000 products), list only, takes well under an hour.

### ⚠️ Limitations

- **Search returns at most 720 products per term**, as on altex.ro. For more, use the category
  link. Search sorts only by recommended, price or name, and a few filters (in stock at the
  supplier, sold by Altex) are not available on search. The run log tells you when that happens.
- **Very large categories** (about 10,000 products or more) are collected in price order when you
  ask for more products than that, so nothing is missed.
- **Filters apply to categories and searches**, not to SKU lists or the whole catalogue.
- **Store stock** shows quantities the way altex.ro reports them: large stocks appear as 6.
- Some product descriptions are supplied by a third-party content provider and loaded separately
  on the page. Those are not captured; `hasExternalRichContent` tells you when a product has one.
- A few hundred products have a SKU containing "/" and no product page. They come with their list
  fields only.
- **No price history inside one run.** Schedule the actor (daily, for example) and compare runs by
  `sku` and `scrapedAt` to track price and stock changes.
- **altex.ro only.** Other shops, including Media Galaxy, are not covered.
- Public pages only: nothing behind a login, the cart or checkout.

### ❓ FAQ

**How do I scrape Altex.ro?** Paste a category, search or product link into Start URLs, set Max
products and press Start. The default input already works.

**Can I get Altex prices by store?** Yes. Switch on "Stock in each store" to get the stock of the
product in every Altex store.

**Can I get one seller's products?** Yes. Put a category link in Start URLs and the seller's ID in
Sellers. You find seller IDs in an earlier run's `sellerId` and `sellerIds` fields.

**How do I track Altex price changes?** Schedule a daily run on the categories you watch and
compare `price`, `regularPrice` and `availability` across runs by `sku`.

**Do I need a proxy?** No. Runs work without one. Apify Proxy is there if your runs are ever
refused, at no extra cost per product.

**What happens on the free plan?** The actor respects your spending limit and stops cleanly with
the products it already has. It never crashes because of the limit.

**Is it legal to scrape Altex.ro?** The actor reads only public pages, without logging in. See
the legal note below.

### ⚖️ Legal

This actor reads publicly available product data only, without logging in. Seller names,
manufacturer contact details, reviewer names and review texts appear exactly as altex.ro displays
them publicly. You are responsible for using the data lawfully, including the GDPR where it
applies.

With **Stock in each store** on, each store entry also carries the store manager's name and the
store's phone number, as altex.ro shows them on the store's page. Names are personal data under the
GDPR. You are responsible for having a lawful basis for processing them under the GDPR and local law.

Unofficial tool. Not affiliated with, endorsed by, or sponsored by Altex Romania or altex.ro. The
Altex name and icon belong to Altex and are used only to identify the site. Product names and
brands belong to their owners.

# Changelog

This Actor's version history is a separate document: https://apify.com/extractify-labs/altex-ro-scraper/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

altex.ro links to scrape: categories (…/cpl/, filtered category links too), searches (…/cauta/?q=…) and products (…/cpd/SKU/). The type of each link is detected for you. Links to other sites or to promo pages are skipped. Leave everything empty to scrape 50 phones.

## `searchTerms` (type: `array`):

Words to search for on altex.ro, as you would type them, for example "frigider no frost". At least 3 characters. Each term returns up to 720 products, the most the site shows.

## `skus` (type: `array`):

Altex product codes to scrape, one per line, for example from an earlier run's `sku` field. Fastest way to re-check prices and stock of products you already know.

## `allProducts` (type: `boolean`):

Scrape every product on altex.ro (more than 590,000). Start URLs, search terms, SKUs and filters are ignored when this is on. Use Max products to stop early.

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

How many products to collect in this run, across all sources. 0 means no limit. A list-only run collects thousands of products per minute; with product details, about 6,000 per hour.

## `brands` (type: `array`):

Only products of these brands, as named on altex.ro, for example "Samsung" or "De'Longhi". A product matches if it has any of them. Applies to categories and searches.

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

Only products at or above this price, in lei, VAT included. Applies to categories and searches.

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

Only products at or below this price, in lei, VAT included. Applies to categories and searches.

## `availability` (type: `string`):

Only products with this stock status. Applies to categories and searches. "In stock at the supplier" works on categories only.

## `promotion` (type: `string`):

Only products on promotion, only SUPER PRET products, or either. Applies to categories and searches.

## `minRating` (type: `string`):

Only products rated at least this many stars. Applies to categories and searches.

## `newArrivalsOnly` (type: `boolean`):

Only products altex.ro marks as new. Applies to categories and searches.

## `withOpenBoxOnly` (type: `boolean`):

Only products that also have open-box (resigilate) units on offer. Applies to categories and searches.

## `soldByAltexOnly` (type: `boolean`):

Skip marketplace sellers and keep products sold by Altex itself. Works on categories only.

## `sellerIds` (type: `array`):

Only products offered by these sellers, by seller ID, one per line (1 is Altex). You find seller IDs in an earlier run's `sellerId` and `sellerIds` fields. Together with Sold by Altex only, products of Altex or of these sellers are kept. Works on categories only.

## `storeIds` (type: `array`):

Only products in stock at these Altex stores, by store ID, one per line. You find store IDs in an earlier run's `stockStoreIds` field or in Stock in each store. A product matches if any of the stores has it. Works on categories only.

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

The order products are collected in, which matters when Max products stops the run early. Search supports only Recommended, Price and Name. Categories with about 10,000 products or more are collected in price order when you ask for more than that.

## `includeProductDetails` (type: `boolean`):

Adds every seller offer, the full gallery, grouped specifications, descriptions, warranty, manufacturer details, category path, open-box units and the star breakdown. About 10 minutes per 1,000 products. Same price per product.

## `includeStoreAvailability` (type: `boolean`):

Adds the stock of each product in every Altex store (store, city, county, quantity, store manager and phone). About one extra request per product. Same price per product.

## `includeShippingOptions` (type: `boolean`):

Adds the delivery methods, carriers, delivery times and fees for the city below. About one extra request per product. Same price per product.

## `shippingCity` (type: `string`):

The city to get delivery options for, as written on altex.ro, without diacritics. Used only with Delivery options.

## `shippingRegion` (type: `string`):

The county (județ) of the delivery city, without diacritics, for example "Bucuresti" or "Cluj". Used only with Delivery options.

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

Adds customer reviews with their texts, ratings, dates and photos. Fetched once per product family. Same price per product.

## `maxReviewsPerProduct` (type: `integer`):

How many reviews to collect for each product. Used only with Reviews.

## `includeQuestions` (type: `boolean`):

Adds customer questions with their answers. Fetched once per product family. Same price per product.

## `maxQuestionsPerProduct` (type: `integer`):

How many questions to collect for each product. Used only with Questions and answers.

## `includeProductPageExtras` (type: `boolean`):

Adds the return window and item condition from the public product page. The slowest option, about one product per second. Same price per product.

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

No proxy is needed, and none is used by default. If your runs are refused, switch on Apify Proxy (datacenter). Residential proxies and your own proxy URLs are not supported.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://altex.ro/telefoane/cpl/"
    }
  ],
  "searchTerms": [],
  "skus": [],
  "allProducts": false,
  "maxItems": 50,
  "brands": [],
  "availability": "any",
  "promotion": "any",
  "minRating": "any",
  "newArrivalsOnly": false,
  "withOpenBoxOnly": false,
  "soldByAltexOnly": false,
  "sellerIds": [],
  "storeIds": [],
  "sortBy": "recommended",
  "includeProductDetails": false,
  "includeStoreAvailability": false,
  "includeShippingOptions": false,
  "shippingCity": "Bucuresti",
  "shippingRegion": "Bucuresti",
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "includeQuestions": false,
  "maxQuestionsPerProduct": 20,
  "includeProductPageExtras": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every scraped product with all of its fields, one item per SKU.

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

The scraped products as a compact table: name, brand, price, stock, rating, seller and link.

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

What this run collected: products per source, filters applied, limits reached and why it stopped.

# 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 = {
    "startUrls": [
        {
            "url": "https://altex.ro/telefoane/cpl/"
        }
    ],
    "maxItems": 50,
    "shippingCity": "Bucuresti",
    "shippingRegion": "Bucuresti",
    "maxReviewsPerProduct": 20,
    "maxQuestionsPerProduct": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractify-labs/altex-ro-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 = {
    "startUrls": [{ "url": "https://altex.ro/telefoane/cpl/" }],
    "maxItems": 50,
    "shippingCity": "Bucuresti",
    "shippingRegion": "Bucuresti",
    "maxReviewsPerProduct": 20,
    "maxQuestionsPerProduct": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("extractify-labs/altex-ro-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 '{
  "startUrls": [
    {
      "url": "https://altex.ro/telefoane/cpl/"
    }
  ],
  "maxItems": 50,
  "shippingCity": "Bucuresti",
  "shippingRegion": "Bucuresti",
  "maxReviewsPerProduct": 20,
  "maxQuestionsPerProduct": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call extractify-labs/altex-ro-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,extractify-labs/altex-ro-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/UMM4Peg44XdMVEkt4/builds/pec2Jqt9sPScWhhH2/openapi.json
