# e-licitatie.ro Scraper — Romanian Public Procurement Tenders (`studio-amba/e-licitatie-ro-scraper`) Actor

Search and extract Romanian public procurement tenders from e-licitatie.ro (SEAP/SICAP), Romania's national tender platform. Filter by keyword, CPV code, contracting authority or date range. Returns buyer, deadline, CPV codes, estimated value and procedure type. No cookies, no login required.

- **URL**: https://apify.com/studio-amba/e-licitatie-ro-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 result scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Romanian Public Procurement Scraper — e-licitatie.ro (SEAP/SICAP) Tenders

Search and extract Romanian public procurement tenders from e-licitatie.ro (SEAP/SICAP), the official national platform every Romanian public authority uses to publish contract notices. Filter by keyword, CPV code, contracting authority or publication date. Returns the buyer, estimated value, bid deadline, CPV classification and procedure type for every matching tender. No cookies, no login required.

### How to scrape e-licitatie.ro data

This actor queries the official e-licitatie.ro (SEAP — Sistemul Electronic de Achiziții Publice, also known as SICAP) contract-notice API directly. SEAP is the single national platform Romanian public authorities are legally required to use for procurement: ministries, county and local councils, hospitals, universities, state-owned companies and utilities all publish here. That makes this actor a complete feed of Romanian public-sector buying activity across construction, IT, medical supplies and services.

The actor pushes a JSON request to SEAP's own contract-notice search endpoint, paginating through results and mapping each notice into a clean, consistent record. None of this requires an account — the `api-pub/NoticeCommon/GetCNoticeList/` endpoint is open, unauthenticated JSON, confirmed live against the production site.

#### Who benefits from this data?

- **Construction and engineering firms** — Monitor new public works tenders by CPV code and estimated value, and track which authorities are actively buying.
- **IT and software vendors** — Find Romanian government IT procurement (CPV 72xxxxxx / 48xxxxxx) before the bid deadline closes.
- **Medical and pharmaceutical suppliers** — Track hospital and public-health tenders for equipment, medicines and consumables.
- **Consultancies and advisory firms** — Build market intelligence on which authorities are buying what, at what value, and under which procedure type.
- **B2B sales and business development teams** — Turn every open tender in your sector into a prospect list with a buyer name and contract value.
- **Market researchers and journalists** — Analyze public spending patterns, procedure types and award timelines across Romania.

#### Search by keyword

Enter any keyword to search tender titles server-side via the SEAP API itself (a real search, not a client-side filter). Use Romanian for the best results — SEAP publications are written in Romanian. Examples: "asfaltare" (asphalt works), "servicii de curatenie" (cleaning services), "echipamente medicale" (medical equipment).

#### Filter by CPV code and contracting authority

- **CPV code**: filter by the EU Common Procurement Vocabulary code or category name, e.g. `45000000` or "constructii" for construction work, `72000000` for IT services
- **Contracting authority**: filter by buyer name, e.g. "Municipiul Cluj-Napoca". The actor resolves the name to SEAP's internal authority ID automatically — use the exact registered name (e.g. "Municipiul X", not "Primaria X") for a reliable match, and check the run log for the resolved entity name to confirm it matched the right buyer.

#### Date range filtering

Set publication date filters to monitor new tenders on a schedule, or search historically for market research. `publishedAfter` and `publishedBefore` accept `YYYY-MM-DD`. Leaving both empty defaults to the last 30 days.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | String | — | Keywords to search in tender titles (server-side search) |
| `cpvCode` | String | — | CPV classification code or category name to filter by |
| `contractingAuthority` | String | — | Buyer/contracting authority name (resolved to SEAP's internal ID automatically) |
| `publishedAfter` | String | 30 days ago | Only tenders published on or after this date (`YYYY-MM-DD`) |
| `publishedBefore` | String | today | Only tenders published on or before this date (`YYYY-MM-DD`) |
| `maxResults` | Integer | `100` | Maximum number of tenders to return (1–10,000) |
| `proxyConfiguration` | Object | Automatic | Apify proxy settings — e-licitatie.ro has no anti-bot, so the default is enough |

Leaving every field empty (`{}`) still returns data: the actor defaults to the most recent 30 days of published tenders across all authorities and categories.

### What data does this scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `noticeId` | String | SEAP-internal notice ID (used to build the tender URL) |
| `cNoticeId` | String | SEAP-internal contract-notice sub-entity ID |
| `procedureId` | String | SEAP-internal procurement procedure ID |
| `noticeNo` | String | Public SEAP notice reference number, e.g. `CN1010402` |
| `tenderTitle` | String | Tender/contract title |
| `contractingAuthorityName` | String | Buyer / contracting authority name |
| `contractingAuthorityFiscalCode` | String | Romanian fiscal/registration code (CUI) of the buyer, when parseable |
| `contractType` | String | Servicii (services), Produse (supplies) or Lucrari (works) |
| `procedureType` | String | Procurement procedure, e.g. "Licitatie deschisa" (open), "Procedura simplificata" (simplified) |
| `procedureState` | String | Current status, e.g. "In desfasurare" (ongoing), "Atribuita" (awarded), "Anulata" (cancelled) |
| `noticeState` | String | Notice publication status, e.g. "Publicat" (published) |
| `contractAssignmentType` | String | e.g. "Contract de achizitii publice", "Acord-cadru" (framework agreement) |
| `cpvCode` | String | CPV classification code |
| `cpvLabel` | String | Human-readable CPV category name (Romanian) |
| `estimatedValue` | Number | Estimated contract value in RON. `null` when the buyer didn't publish one. |
| `currency` | String | Always `"RON"` — SEAP publishes estimated values in Romanian Lei, never converted |
| `estimatedValueFormatted` | String | Raw SEAP-formatted value string, e.g. `"362000 RON"` |
| `publicationDate` | String | ISO 8601 timestamp the notice was published |
| `deadline` | String | ISO 8601 bid submission deadline. `null` for closed, awarded or cancelled procedures. |
| `deadlineFormatted` | String | Raw SEAP-formatted deadline string, e.g. `"05.10.2026 15:00"` |
| `isOnline` | Boolean | True when bids can be submitted electronically through SEAP |
| `hasLots` | Boolean | True when the tender is split into multiple lots |
| `hasAppeal` | Boolean | True when the procedure has a recorded appeal (contestatie) |
| `errataNo` | Integer | Number of corrections published for this notice |
| `url` | String | Direct link to the tender detail page on e-licitatie.ro |
| `scrapedAt` | String | ISO 8601 timestamp this record was scraped |
| `searchQuery` | String | Input keyword echoed back, empty when browsing without one |

### Example output

```json
{
    "noticeId": "101392480",
    "cNoticeId": "100244409",
    "procedureId": "100331218",
    "noticeNo": "SCN1179527",
    "tenderTitle": "Servicii de consultanta pentru managementul si implementarea a 5 proiecte de eficientizare energetica a cladirilor rezidentiale",
    "contractingAuthorityName": "Municipiul Lupeni",
    "contractingAuthorityFiscalCode": "4375046",
    "contractType": "Servicii",
    "procedureType": "Procedura simplificata",
    "procedureState": "In desfasurare",
    "noticeState": "Publicat",
    "contractAssignmentType": "Contract de achizitii publice",
    "cpvCode": "79411000-8",
    "cpvLabel": "Servicii generale de consultanta in management (Rev.2)",
    "estimatedValue": 362000,
    "currency": "RON",
    "estimatedValueFormatted": "362000 RON",
    "publicationDate": "2026-09-05T19:47:08.000Z",
    "deadline": "2026-10-05T12:00:00.000Z",
    "deadlineFormatted": "05.10.2026 15:00",
    "isOnline": true,
    "hasLots": true,
    "hasAppeal": false,
    "errataNo": 0,
    "url": "https://e-licitatie.ro/pub/notices/ca-notices/view-c/101392480",
    "scrapedAt": "2026-09-06T14:13:05.562Z",
    "searchQuery": ""
}
```

### Cost estimate

This actor uses standard Apify proxy and does one lightweight JSON call per 500 tenders (plus one warm-up request per run), so a run of 1,000 tenders typically costs well under $0.50 in compute. Actual cost depends on your Apify plan and any proxy add-ons. The final usage cost only settles after the run reports SUCCEEDED — checking the dataset mid-run will undercount it.

### Limitations

- SEAP caps any single query at 3,000 matching results — narrow the date range, CPV code or keyword to scrape beyond that in one run
- `estimatedValue` and `deadline` are `null` where the buyer didn't publish one (common for framework agreements and some simplified procedures) — this is not a scraper error
- Contracting-authority name matching picks the closest registered name; check the run log to confirm it resolved to the buyer you meant
- Data is scraped from the public SEAP API and may change without notice
- Respect e-licitatie.ro's terms of service and use responsibly

### Related Scrapers

- [simap-scraper](https://apify.com/studio-amba/simap-scraper) — Swiss public procurement tenders (simap.ch)
- [tenderned-scraper](https://apify.com/studio-amba/tenderned-scraper) — Dutch public procurement tenders (TenderNed)
- [ted-eu-procurement-scraper](https://apify.com/studio-amba/ted-eu-procurement-scraper) — EU-wide procurement notices (TED)
- [belgian-procurement-scraper](https://apify.com/studio-amba/belgian-procurement-scraper) — Belgian public procurement tenders
- [eu-procurement-award-radar](https://apify.com/studio-amba/eu-procurement-award-radar) — Cross-EU procurement award tracking

### Maintained by Studio Amba

We run 700+ scrapers for European websites, and the priority is keeping
every one of them working. Automated runs test this actor against the live
site and verify the output is complete. When the website changes, the
scraper usually gets repaired the same day, without you having to report
anything. Questions and issues go straight to the people who built it, and
most get an answer the same day.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API, maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.

# Actor input Schema

## `searchQuery` (type: `string`):

Search tenders by keyword (matched against the contract title by the SEAP API). Use Romanian for best results. Leave empty to browse all recent tenders instead. Examples: 'asfaltare', 'servicii de curatenie', 'echipamente medicale'.

## `cpvCode` (type: `string`):

Filter by a CPV (Common Procurement Vocabulary) classification code, e.g. '45000000' for construction work or '72000000' for IT services. Leave empty for all categories.

## `contractingAuthority` (type: `string`):

Filter by the buyer/contracting authority name, e.g. 'Primaria', 'Consiliul Judetean'. Leave empty for all buyers.

## `publishedAfter` (type: `string`):

Only tenders published on or after this date. Format: YYYY-MM-DD. Defaults to 30 days ago when left empty.

## `publishedBefore` (type: `string`):

Only tenders published on or before this date. Format: YYYY-MM-DD. Defaults to today when left empty.

## `maxResults` (type: `integer`):

Maximum number of tenders to return. SEAP caps any single query at 3,000 results — narrow the date range, CPV code or keyword to go beyond that.

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

Apify proxy configuration. e-licitatie.ro's public API has no anti-bot protection, so the default (automatic) proxy is enough.

## Actor input object example

```json
{
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/e-licitatie-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 = {
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/e-licitatie-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 '{
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/e-licitatie-ro-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/e-licitatie-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/cFtF9fRAiEGSiuVGU/builds/9SARDoH2abtOHCmxA/openapi.json