# PaginiAurii Scraper - Romania Business Directory (`crawlerbros/paginiaurii-scraper`) Actor

Scrape PaginiAurii.ro (Pagini Aurii), Romania's leading business directory. Search by category and city, browse all businesses in a city, or fetch full business profiles by URL. Get names, addresses, phone numbers, ratings, opening hours, websites, emails, registry/financial data, and more.

- **URL**: https://apify.com/crawlerbros/paginiaurii-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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/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

## PaginiAurii Scraper - Romania Business Directory

Scrape **PaginiAurii.ro** (Pagini Aurii) — Romania's leading business directory. Search any business category in any Romanian city, browse every business registered in a city, or fetch full company profiles directly by URL. Get names, addresses, phone numbers, ratings, opening hours, websites, emails, and rich business registry/financial data (tax code, CAEN activity code, turnover, employee count, and more). No login, no cookies, no API key required.

### What this actor does

- **Three modes:** `search` (category + optional city), `byCity` (every business registered in a city), and `byUrl` (direct business profile URLs)
- **38+ curated business categories** to pick from, or type any custom category/keyword (PaginiAurii matches free text like a keyword search)
- **42 curated Romanian cities and county seats** — from Bucureşti down to every county capital — or search the whole country at once
- **Sort by** relevance, rating, or name (A-Z)
- **Filter by** "open now" or minimum star rating (0-5)
- **Full Romanian diacritic support** — ă, â, î, ș, ț etc. are handled correctly in both input and output
- **Rich business profiles** — description, opening hours, products/services, keywords, service area, payment methods, and Romanian company registry data: tax code (CUI), registration number, legal form, CAEN activity code, activity start date, employee count, subscribed capital, turnover, and profit
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `name` — business name
- `category` — primary listed activity domain
- `rating`, `ratingCount` — average star rating (0-5) and total number of ratings
- `address`, `street`, `city`, `sector`, `postalCode`, `county` — parsed from the business's published address
- `latitude`, `longitude` — GPS coordinates
- `isOpenNow`, `openingStatusNote` — live open/closed status
- `phone`, `website`, `email`
- `isPromoted` — whether this is a paid/promoted listing on PaginiAurii (mode=search/byCity)
- `description` — free-text business description (when profile fetched)
- `openingHours[]` — structured opening hours (`{day, hours}` per weekday; when profile fetched)
- `productsServices[]`, `keywords[]` — product/service tags and keyword tags the business registered (when profile fetched)
- `servedArea[]` — cities/counties the business says it serves (when profile fetched)
- `paymentMethods[]` — accepted payment methods (when profile fetched)
- `status`, `taxCode`, `registrationNumber`, `legalForm`, `caenCode`, `caenDescription`, `activityStartDate`, `employeeCount`, `subscribedCapital`, `turnover`, `profit` — official Romanian trade-registry/financial data published on the profile (when profile fetched and available)
- `imageUrl` — listing thumbnail photo (mode=search/byCity, when the business has one)
- `searchQuery`, `searchCity` — the search parameters used (mode=search/byCity)
- `sourceUrl` — canonical PaginiAurii profile URL for the business
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `search` | `search` (category + optional city), `byCity` (all businesses in a city), or `byUrl` (fetch by URL) |
| `category` | string (select) | `Restaurante` | Pick a common category, or `custom` to use `customCategory` (mode=search) |
| `customCategory` | string | – | Any free-text category/keyword, overrides `category` (mode=search) |
| `city` | string (select) | `Bucureşti` | Romanian city/county-seat to search in. Leave empty for nationwide (mode=search); required for mode=byCity |
| `sortBy` | string (select) | `relevance` | `relevance` / `rating` (highest first) / `name` (A-Z) — applied client-side across the fetched batch |
| `openNowOnly` | boolean | `false` | Only return businesses currently open |
| `minRating` | integer | `0` (no minimum) | Only return businesses rated at least 0-5 stars |
| `fetchDetails` | boolean | `false` | Also visit each business's profile page for richer data (slower) |
| `businessUrls` | array | – | PaginiAurii profile URLs to fetch directly (mode=byUrl) |
| `maxItems` | int | `20` | Hard cap on returned records (1-1000) |
| `proxyConfiguration` | object | Apify AUTO proxy | Datacenter proxy used to stay reliable against PaginiAurii's edge proxy |

#### Example: search restaurants in Bucureşti

```json
{
  "mode": "search",
  "category": "Restaurante",
  "city": "Bucureşti",
  "maxItems": 20
}
````

#### Example: highest-rated dentists nationwide, with full profiles

```json
{
  "mode": "search",
  "category": "Cabinete stomatologice",
  "sortBy": "rating",
  "fetchDetails": true,
  "maxItems": 30
}
```

#### Example: all businesses currently open in Cluj-Napoca, 4+ stars

```json
{
  "mode": "byCity",
  "city": "Cluj-Napoca",
  "openNowOnly": true,
  "minRating": 4,
  "maxItems": 50
}
```

#### Example: custom keyword search

```json
{
  "mode": "search",
  "customCategory": "instalatori sanitare",
  "city": "Timişoara",
  "maxItems": 40
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "byUrl",
  "businessUrls": [
    { "url": "https://www.paginiaurii.ro/companii/BUFTEA/L5918216/CIRESUL+SALBATIC/" }
  ]
}
```

### Use cases

- **Local lead generation** — build a prospect list of Romanian businesses by trade and city for B2B outreach
- **Market research** — measure business density and average ratings for a category across Romanian regions
- **Directory aggregation** — feed structured Romanian business data into your own local-search product
- **Competitor mapping** — see who else operates in a category and area, with ratings and contact info
- **Compliance / due diligence** — pull CUI (tax code), registration number, legal form, and CAEN activity code alongside contact data

### Limitations

- **`sortBy` is applied client-side.** PaginiAurii's search-results pages don't expose a server-side sort parameter, so `rating`/`name` sorting is applied across the batch of records this run actually fetched, not the entire category.
- **`openNowOnly` and `minRating` are applied client-side.** A business with no open/closed indicator or no rating on PaginiAurii is only excluded by `minRating` (which requires a rating to compare against); it is *not* excluded by `openNowOnly`, since an unknown status is treated as "don't filter this one out" rather than "closed".
- **Company registry/financial fields depend on the business's own published profile.** Not every business discloses turnover, profit, employee count, or subscribed capital — these fields are simply omitted when PaginiAurii doesn't have them.
- **Category is a free-text match, not a fixed taxonomy.** PaginiAurii's true category system is CAEN-code granular with thousands of entries; the curated list in this actor's `category` dropdown covers the most commonly searched business types. Any Romanian business term works via `customCategory`.
- **No canonical city/county list is published by the source.** The `city` dropdown is a curated list of Bucureşti plus Romania's 41 county-seat localities. To search a smaller town not in the dropdown, use the Apify Console's "Custom value" option on the `city` field (or pass any locality string via the API) — PaginiAurii accepts any real Romanian locality name in its URL path, not just the curated ones.

### FAQ

**What data source does this actor use?**
It reads the publicly available search, city-browse, and business-profile pages on PaginiAurii.ro, Romania's leading business directory. No account or API key is needed.

**Is this affiliated with PaginiAurii?**
No. This is an independent, third-party actor that reads publicly accessible pages.

**Why do some businesses have no rating, phone, or website?**
PaginiAurii only shows a rating once a business has received at least one review, and only shows contact/registry details a business itself provided. Fields with no data are simply omitted from the record rather than shown as empty or null.

**What's the difference between the address parts and the raw `address` field?**
`address` is the full address string exactly as published. `street`, `city`, `sector`, `postalCode`, and `county` are parsed out of it for convenience — they're included alongside `address`, not instead of it.

**Can I search all of Romania at once?**
Yes — leave `city` empty (or select "Nationwide") in `mode=search` for a countrywide search across all localities.

**Why is `fetchDetails` off by default?**
Fetching each business's full profile page requires one extra request per result, which is slower. Turn it on when you need description, opening hours, products/services, keywords, service area, payment methods, or company registry/financial data.

**Does this actor need a proxy or login?**
No login or cookies are required. PaginiAurii's edge proxy occasionally rejects requests from some datacenter IPs, so this actor uses Apify's free AUTO (datacenter) proxy group by default to stay reliable — there is no paid proxy dependency.

**What does `caenCode` mean?**
CAEN is Romania's official National Classification of Economic Activities code (similar to NACE/SIC codes elsewhere). `caenCode` is the numeric code and `caenDescription` is its official activity description, both taken directly from the business's own registry entry as published on its PaginiAurii profile.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search a category (optionally scoped to a city), browse every business in a city, or fetch full business profiles from direct PaginiAurii URLs.

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

Business category / activity domain to search for. Pick a common category, or choose 'Custom category' and type your own below (mode=search). PaginiAurii matches this like a free-text/keyword search, so any Romanian business term works.

## `customCategory` (type: `string`):

Free-text category or keyword not in the curated list above, e.g. 'instalatori sanitare' or 'traduceri autorizate' (mode=search). Takes priority over 'Category' when set. PaginiAurii matches this like a keyword search, so most Romanian business terms work.

## `city` (type: `string`):

Romanian city or county-seat locality to search in (mode=search: leave empty to search nationwide; mode=byCity: required).

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

How to order search results after fetching (mode=search / byCity). PaginiAurii itself only returns relevance order, so 'rating' and 'name' are applied client-side across the fetched batch.

## `openNowOnly` (type: `boolean`):

Only return businesses that are currently open, based on PaginiAurii's own live open/closed status (mode=search / byCity).

## `minRating` (type: `integer`):

Only return businesses rated at least this many stars, e.g. 4 for 4.0+ (mode=search / byCity). 0 means no minimum. Businesses with no rating yet are excluded once this is set above 0.

## `fetchDetails` (type: `boolean`):

For each search/browse result, also visit its business profile page to collect email, website, description, opening hours, products/services, keywords, served area, payment methods, and business registry/financial data (tax code, CAEN code, turnover, employees, etc). Slower -- one extra request per result (mode=search / byCity).

## `businessUrls` (type: `array`):

Direct PaginiAurii business profile URLs to fetch, e.g. https://www.paginiaurii.ro/companii/BUFTEA/L5918216/CIRESUL+SALBATIC/. Use the 'sourceUrl' field from search results.

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

Hard cap on the number of business records to return.

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

PaginiAurii.ro's edge proxy can reject requests from some datacenter source IPs. This actor defaults to Apify's free AUTO (datacenter) proxy group so runs stay reliable; it automatically rotates sessions and falls back to a Chrome-impersonation HTTP client on repeated blocks.

## Actor input object example

```json
{
  "mode": "search",
  "category": "Restaurante",
  "city": "Bucureşti",
  "sortBy": "relevance",
  "openNowOnly": false,
  "minRating": 0,
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped PaginiAurii.ro business listings.

# 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 = {
    "mode": "search",
    "category": "Restaurante",
    "city": "Bucureşti",
    "sortBy": "relevance",
    "openNowOnly": false,
    "minRating": 0,
    "fetchDetails": false,
    "businessUrls": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/paginiaurii-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 = {
    "mode": "search",
    "category": "Restaurante",
    "city": "Bucureşti",
    "sortBy": "relevance",
    "openNowOnly": False,
    "minRating": 0,
    "fetchDetails": False,
    "businessUrls": [],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/paginiaurii-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",
  "category": "Restaurante",
  "city": "Bucureşti",
  "sortBy": "relevance",
  "openNowOnly": false,
  "minRating": 0,
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/paginiaurii-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PaginiAurii Scraper - Romania Business Directory",
        "description": "Scrape PaginiAurii.ro (Pagini Aurii), Romania's leading business directory. Search by category and city, browse all businesses in a city, or fetch full business profiles by URL. Get names, addresses, phone numbers, ratings, opening hours, websites, emails, registry/financial data, and more.",
        "version": "1.0",
        "x-build-id": "e9f4AmevfXsM9L9uc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~paginiaurii-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-paginiaurii-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/crawlerbros~paginiaurii-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-paginiaurii-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/crawlerbros~paginiaurii-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-paginiaurii-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCity",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch: search a category (optionally scoped to a city), browse every business in a city, or fetch full business profiles from direct PaginiAurii URLs.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "custom",
                            "Restaurante",
                            "Fast-food",
                            "Pizzerii",
                            "Baruri",
                            "Cafenele",
                            "Hoteluri",
                            "Agenţii de turism",
                            "Arhitectură",
                            "Contabilitate",
                            "Case de marcat",
                            "Bucătării industriale",
                            "Computere - software",
                            "Amenajări interioare şi exterioare",
                            "Ambalaje",
                            "Construcţii - proiectare, consultanţă",
                            "Confecţii - producători, distribuitori",
                            "Comerţ cu amănuntul în magazine nespecializate",
                            "Avocaţi",
                            "Service auto",
                            "Clinici veterinare",
                            "Frizerii - saloane de coafură",
                            "Centre de fitness",
                            "Agenţii de publicitate",
                            "Transport de persoane - rutier",
                            "Oficii poştale",
                            "Centre de copiere",
                            "Academii, universităţi şi colegii universitare",
                            "Repararea aparatelor electronice de uz casnic",
                            "Medicină - cardiologie",
                            "Suplimente nutritive",
                            "Cărţi - distribuţie, depozite",
                            "Fabricarea produselor din carne",
                            "Încălţăminte - producători, distribuitori",
                            "Abatoare",
                            "Acoperişuri şi ţigle",
                            "Automobile - staţii ITP",
                            "Farmacii",
                            "Cabinete stomatologice",
                            "Notari publici",
                            "Firme de curăţenie"
                        ],
                        "type": "string",
                        "description": "Business category / activity domain to search for. Pick a common category, or choose 'Custom category' and type your own below (mode=search). PaginiAurii matches this like a free-text/keyword search, so any Romanian business term works.",
                        "default": "Restaurante"
                    },
                    "customCategory": {
                        "title": "Custom category (overrides selection above)",
                        "type": "string",
                        "description": "Free-text category or keyword not in the curated list above, e.g. 'instalatori sanitare' or 'traduceri autorizate' (mode=search). Takes priority over 'Category' when set. PaginiAurii matches this like a keyword search, so most Romanian business terms work."
                    },
                    "city": {
                        "title": "City",
                        "enum": [
                            "",
                            "Bucureşti",
                            "Cluj-Napoca",
                            "Timişoara",
                            "Iaşi",
                            "Constanţa",
                            "Craiova",
                            "Braşov",
                            "Galaţi",
                            "Ploieşti",
                            "Oradea",
                            "Brăila",
                            "Arad",
                            "Piteşti",
                            "Sibiu",
                            "Bacău",
                            "Târgu Mureş",
                            "Baia Mare",
                            "Buzău",
                            "Botoşani",
                            "Satu Mare",
                            "Râmnicu Vâlcea",
                            "Drobeta-Turnu Severin",
                            "Suceava",
                            "Piatra Neamţ",
                            "Târgu Jiu",
                            "Târgovişte",
                            "Focşani",
                            "Bistriţa",
                            "Reşiţa",
                            "Tulcea",
                            "Slatina",
                            "Călăraşi",
                            "Giurgiu",
                            "Deva",
                            "Zalău",
                            "Sfântu Gheorghe",
                            "Miercurea Ciuc",
                            "Alexandria",
                            "Vaslui",
                            "Alba Iulia",
                            "Slobozia",
                            "Buftea"
                        ],
                        "type": "string",
                        "description": "Romanian city or county-seat locality to search in (mode=search: leave empty to search nationwide; mode=byCity: required).",
                        "default": "Bucureşti"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order search results after fetching (mode=search / byCity). PaginiAurii itself only returns relevance order, so 'rating' and 'name' are applied client-side across the fetched batch.",
                        "default": "relevance"
                    },
                    "openNowOnly": {
                        "title": "Open now only",
                        "type": "boolean",
                        "description": "Only return businesses that are currently open, based on PaginiAurii's own live open/closed status (mode=search / byCity).",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return businesses rated at least this many stars, e.g. 4 for 4.0+ (mode=search / byCity). 0 means no minimum. Businesses with no rating yet are excluded once this is set above 0.",
                        "default": 0
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each search/browse result, also visit its business profile page to collect email, website, description, opening hours, products/services, keywords, served area, payment methods, and business registry/financial data (tax code, CAEN code, turnover, employees, etc). Slower -- one extra request per result (mode=search / byCity).",
                        "default": false
                    },
                    "businessUrls": {
                        "title": "Business profile URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct PaginiAurii business profile URLs to fetch, e.g. https://www.paginiaurii.ro/companii/BUFTEA/L5918216/CIRESUL+SALBATIC/. Use the 'sourceUrl' field from search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "PaginiAurii business profile URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "PaginiAurii.ro's edge proxy can reject requests from some datacenter source IPs. This actor defaults to Apify's free AUTO (datacenter) proxy group so runs stay reliable; it automatically rotates sessions and falls back to a Chrome-impersonation HTTP client on repeated blocks.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
