# Pagini Aurii Company Contacts Scraper (`automation-lab/pagini-aurii-company-directory-contacts`) Actor

Export public Pagini Aurii Romanian company listings by keyword and locality: directory IDs, names, phones, addresses, sectors and source URLs. Missing emails stay null.

- **URL**: https://apify.com/automation-lab/pagini-aurii-company-directory-contacts.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.36 / 1,000 item extracteds

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

## Pagini Aurii Company Contacts Scraper

Refresh **Pagini Aurii company contacts** for Romanian business-directory research. Search by Romanian keyword and optional locality, then export public company IDs, names, business phones, addresses, directory sectors and source profile URLs. Listings remain useful even when an email is missing: the Actor returns null rather than inventing a contact.

### Who is it for?

Procurement teams can discover local suppliers; researchers can assemble reproducible sector samples; data teams can refresh company-directory tables for internal analysis. This is a directory export, not an outreach service or a guaranteed national database.

### Why use this Actor?

- Retain public businesses without imposing an email requirement.
- Deduplicate by the directory's stable company identifier across search pages and keywords.
- Keep source URLs, the first matching input keyword and retrieval timestamps for auditability.
- Bound collection by unique company count and pages per keyword.
- Use ordinary public search HTML without login, browser rendering or external website enrichment.

Unlike our trade-only contact Actor, this export does not restrict categories to five trades or require both phone and email. Search relevance remains controlled by the directory.

### What data does it extract?

| Field | Meaning |
| --- | --- |
| `companyId` | Directory L-number, **not** a Romanian tax/CUI identifier |
| `companyName` | Company name displayed on the search card |
| `phones` | Array of publicly listed business telephone strings; may be empty |
| `email` | Public search-card email, or null; often absent |
| `address` | Displayed postal address, or null |
| `locality` | Locality segment decoded from the source profile URL |
| `sector` | Directory category label, or null |
| `profileUrl` | Source company profile URL |
| `searchUrl` | First search page yielding the company |
| `keyword` | First input keyword yielding the company |
| `scrapedAt` | UTC retrieval time |

No private contacts, email inference, off-site crawling, registry enrichment or contact verification are performed. Profile URLs are provenance links; the Actor does not fetch profile details.

### Getting started

1. Enter a Romanian keyword such as `arhitecti`, `tamplarie` or `instalatii electrice`.
2. Optionally set `locality`, for example `Bucuresti`.
3. Start with `maxItems: 25` and `maxPagesPerSearch: 2`.
4. Run and inspect the default dataset.
5. Download JSON, CSV or Excel using Apify's dataset export controls.

```json
{
  "keywords": ["arhitecti"],
  "locality": "Bucuresti",
  "maxItems": 25,
  "maxPagesPerSearch": 2
}
```

### Input parameters

| Input | Default | Behavior |
| --- | --- | --- |
| `keywords` | `["arhitecti"]` | 1–20 nonempty strings, each at most 100 characters; one separate source search per keyword |
| `locality` | Empty | Optional source locality hint, at most 100 characters |
| `maxItems` | 100 | Global unique company limit, 1–10000, after deduplication |
| `maxPagesPerSearch` | 5 | First page included; maximum 1–100 pages per keyword |

Keyword whitespace is trimmed and identical keywords are deduplicated. Keywords are processed in input order, not combined as an AND query. Search matching, spelling correction and ranking are upstream: this is not an exact category or whole-word filter. The locality is likewise a search hint, not a strict exclusion filter. Nearby, sponsored or unrelated results can occur. Empty locality searches across the directory without promising national completeness.

The first matching keyword receives attribution when several searches return the same company. Source exhaustion, a page bound, global item bound, runtime or billing limits may stop collection. Zero is invalid, not unlimited. Unsupported fields and malformed input are rejected rather than silently ignored.

### Example output

A real public directory result observed in an architecture search (source values can change):

```json
{
  "companyId": "L4315201",
  "companyName": "ELA DESIGN S.R.L.",
  "phones": ["0723-520 235"],
  "email": null,
  "address": "STR. OBOGA, Nr. 5, Bl.160, Sc.1, Et.2, Ap.8, BUCUREŞTI, Sector 6, Cod Postal 062197",
  "locality": "BUCUREŞTI, Sector 6",
  "sector": "Arhitectură",
  "profileUrl": "https://www.paginiaurii.ro/companii/BUCURE%C5%9ETI,+Sector+6/L4315201/ELA+DESIGN+S.R.L./",
  "searchUrl": "https://www.paginiaurii.ro/cauta/arhitecti%2bnear%2bBucuresti/",
  "keyword": "arhitecti",
  "scrapedAt": "2026-10-26T21:05:44.387Z"
}
```

### Run summary and coverage

`SUMMARY` in the run's key-value store contains request, retry, byte, page, scanned-card and saved-company counters. Saved companies are not a census or exact count of every business in a branch. These counters are included with the result export.

### How much does it cost to export Pagini Aurii company contacts?

A one-time `start` event is charged per run, plus one `item` event per unique company exported. Duplicate or rejected records are not item-charged. The price is $0.005 per run plus a BRONZE item price of $0.0056 per company. At BRONZE, 1, 5 and 25 companies cost approximately $0.0106, $0.033 and $0.145 respectively. Item prices are FREE $0.00644, BRONZE $0.0056, SILVER $0.004368 and GOLD/PLATINUM/DIAMOND $0.00336, plus the $0.005 start event. Consult the Apify pricing panel for your applicable tier.

Tiers depend on your aggregate monthly Apify Store spend, not the number of rows in this run. Infrastructure usage and Actor event charges are different concepts. Payout estimates can be adjusted for refunds, fraud, disputes, taxes, corrections and clawbacks.

### Limits and failure behavior

The Actor follows source next-page links sequentially and stops at configured limits. It does not discover every category, guarantee exact sector counts, enrich emails or promise all Romanian companies. Missing contacts remain null/empty. Listing values can be stale or inaccurate at the source.

Transient network errors, HTTP 429 and selected 5xx responses receive at most two retries with backoff. A recognized no-results message returns an empty dataset, including the directory's unusual HTTP 400 no-results response. Challenges, other HTTP errors and unrecognized layouts fail the run. A failed run can contain partial rows; do not treat it as a complete successful export. No automatic paid proxy fallback is enabled.

### Integrations and recurring refreshes

Use an Apify Schedule to repeat the same input. Join datasets by `companyId` in your own database or spreadsheet and compare timestamps and fields. The Actor does not keep cross-run history, detect changes or send alerts. A webhook can send the run's dataset ID to Make, Zapier or a custom ETL pipeline. Full exports should remain in storage rather than an LLM conversation.

### API usage

Keep tokens in environment variables, never in shared source files.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~pagini-aurii-company-directory-contacts/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["arhitecti"],"locality":"Bucuresti","maxItems":25,"maxPagesPerSearch":2}'
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pagini-aurii-company-directory-contacts').call({
  keywords: ['arhitecti'], locality: 'Bucuresti', maxItems: 25, maxPagesPerSearch: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/pagini-aurii-company-directory-contacts').call(
    run_input={'keywords': ['arhitecti'], 'locality': 'Bucuresti', 'maxItems': 25, 'maxPagesPerSearch': 2})
print(client.dataset(run['defaultDatasetId']).list_items(limit=25).items)
```

Check terminal run status before treating rows as a completed result; asynchronous POST returns run metadata, not the rows themselves.

### Use with MCP

For authorized clients, select this Actor explicitly:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/pagini-aurii-company-directory-contacts'
```

Equivalent Claude Desktop, Cursor, and VS Code client configuration (set authentication securely in your client):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/pagini-aurii-company-directory-contacts"
    }
  }
}
```

Example prompt: “Export up to 25 architecture listings near Bucuresti, then show company names and source URLs. Keep missing emails null.”

Discover actual names and argument schemas with scoped `tools/list`. Actor selection also adds run/status, dataset, key-value and abort tools; discovery itself grants no execution permission. Start an authorized run once and retain its run/storage IDs. The server waits at most 45 seconds; if still running, check **that same run** with bounded backoff (2, 4, 8 seconds, capped at 10) up to a 120-second deadline. A client timeout is not a reason to start another run. At deadline report pending and the run ID; report terminal failure and partial rows honestly.

On success, fetch dataset pages with explicit limit, offset and needed fields. A reasonable consumer budget is 20 source rows per page, at most 100 rows and 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. Enforce bytes host-side, including oversized rows; disclose omitted/truncated content and the next source offset. If your client cannot intercept responses, do not promise a hard byte ceiling. This limits consumer context, not Actor collection. No universal token savings or client caching behavior is promised.

### Legality, responsible use and diagnostics

Use public business information only for lawful research and respect source terms, privacy law, suppression requests and applicable marketing rules. Public visibility is not blanket consent to outreach. This Actor is independent of Pagini Aurii and is not affiliated with the directory.

Apify datasets, run logs and the summary remain in your account until deleted manually or by your platform retention policy; this Actor does not create cross-run caches or fixed shared datasets. Delete a run and its associated storages through Apify when no longer needed. For help, open an issue on this Actor's Apify Issues tab with a run link and non-sensitive reproduction details.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. No AI provider processes search results.

### FAQ and troubleshooting

**Why is email null?** Many search cards do not display an email. Null is honest absence, not a failed enrichment attempt. The Actor never opens unrelated sites or guesses addresses.

**Why are nearby places or unrelated sectors included?** Keyword and locality are source search hints. Apply your own downstream filters to the returned category/address if strict matching is required.

**Why fewer rows than requested?** The source may exhaust results, duplicate businesses across keywords, or reach the page bound first. maxItems is a cap, not a promised quantity.

**What if a run fails?** Inspect the error and SUMMARY when available. A changed layout or challenge is reported as failure, not empty success. Keep maxItems and page limits modest while evaluating a query.

### Related Actors

- [Romanian trade company contacts](https://apify.com/automation-lab/romania-trade-company-contact-directory) for the narrower selected-trade workflow requiring both phone and email.

For arbitrary supplied business websites, use a separate contact-extraction workflow; this directory export does not claim those websites' email availability.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/pagini-aurii-company-directory-contacts/changelog.md

# Actor input Schema

## `keywords` (type: `array`):

1–20 sector or business keywords sent separately to the directory's search. Matching and ranking are upstream, not exact category filters; unrelated results can occur. Whitespace is trimmed and identical keywords deduplicated. Omitted value uses arhitecti.

## `locality` (type: `string`):

Optional Romanian locality passed to the directory for every keyword, at most 100 characters. Empty or omitted searches nationwide. This is an upstream search hint, not a strict city exclusion filter; nearby or sponsored listings can appear.

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

Global run limit across all keywords, after deduplication by directory company ID. Range 1–10000; default 100. Zero is invalid. Collection can stop earlier at source exhaustion, page limits, runtime or billing limits; no national completeness is promised.

## `maxPagesPerSearch` (type: `integer`):

Maximum search pages fetched for each distinct keyword, 1–100; default 5. The first page counts. Follow source next links until this limit, exhaustion or global maxItems. Zero is invalid; source page sizes vary.

## Actor input object example

```json
{
  "keywords": [
    "arhitecti"
  ],
  "locality": "Bucuresti",
  "maxItems": 20,
  "maxPagesPerSearch": 2
}
```

# Actor output Schema

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

Unique company listings with public contacts and source provenance.

## `summary` (type: `string`):

Request, retry, byte, scanned-card and saved-company counters for this run.

# 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 = {
    "keywords": [
        "arhitecti"
    ],
    "locality": "Bucuresti",
    "maxItems": 20,
    "maxPagesPerSearch": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pagini-aurii-company-directory-contacts").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 = {
    "keywords": ["arhitecti"],
    "locality": "Bucuresti",
    "maxItems": 20,
    "maxPagesPerSearch": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pagini-aurii-company-directory-contacts").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 '{
  "keywords": [
    "arhitecti"
  ],
  "locality": "Bucuresti",
  "maxItems": 20,
  "maxPagesPerSearch": 2
}' |
apify call automation-lab/pagini-aurii-company-directory-contacts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/pagini-aurii-company-directory-contacts"
        }
    }
}
```

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/srdkPPchn2grUOe3v/builds/j2JPhwnJdalcLWZPv/openapi.json