# Bulgarian Public Procurement Monitor (`susurrant_cowl/bulgarian-public-procurement-monitor`) Actor

Search and filter official Bulgarian public procurement tenders by keywords, CPV codes, buyer, value, category, status, and deadlines via API.

- **URL**: https://apify.com/susurrant\_cowl/bulgarian-public-procurement-monitor.md
- **Developed by:** [Renegade](https://apify.com/susurrant_cowl) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Bulgarian Public Procurement Monitor

Find relevant Bulgarian public tenders without manually downloading and parsing daily government data files.

This Actor reads the official **CAIS EOP / ЦАИС ЕОП** Open Contracting Data Standard (OCDS) releases and returns clean, filterable tender records for monitoring, lead generation, research, and workflow automation.

### What you can do

- Search tender titles, descriptions, buyers, and lots using Bulgarian or English keywords
- Filter by CPV code prefix, buyer, procurement category, value, status, and deadline
- Receive normalized tender and lot data with direct register links
- Process one day or a date range of up to 32 days
- Schedule daily monitoring and connect results to APIs, webhooks, Sheets, Slack, email, n8n, or a CRM
- Optionally include the original OCDS release in each result

### Quick start

To retrieve up to 100 active notices from the latest available default date, run with:

```json
{
  "onlyActive": true,
  "maxItems": 100
}
````

To find computer-equipment opportunities:

```json
{
  "startDate": "2026-06-30",
  "endDate": "2026-06-30",
  "keywords": ["компютър", "лаптоп"],
  "keywordMode": "any",
  "cpvPrefixes": ["302"],
  "onlyActive": true,
  "maxItems": 100
}
```

If dates are omitted, the Actor reads yesterday's UTC publication bundle. The official file can appear later in the day, so scheduled monitoring should run after the source is published.

### Input

| Field | Type | Purpose |
|---|---|---|
| `startDate` | string | First source publication date in `YYYY-MM-DD` format |
| `endDate` | string | Last source publication date; maximum range is 32 days |
| `keywords` | string\[] | Text matched against title, description, buyer name, and lot titles |
| `keywordMode` | `any` or `all` | Whether any or all keywords must match |
| `cpvPrefixes` | string\[] | CPV prefixes such as `302` or full codes such as `30213100` |
| `buyerKeywords` | string\[] | Text matched against the contracting authority name |
| `categories` | string\[] | Any of `goods`, `services`, or `works` |
| `minValue` | number | Minimum published tender value in the record's original currency |
| `maxValue` | number | Maximum published tender value in the record's original currency |
| `deadlineFrom` | string | Earliest accepted deadline date in `YYYY-MM-DD` format |
| `deadlineTo` | string | Latest accepted deadline date in `YYYY-MM-DD` format |
| `onlyActive` | boolean | Exclude tenders not marked `active`; defaults to `true` |
| `maxItems` | integer | Maximum dataset records; defaults to `100` |
| `includeRaw` | boolean | Attach the complete source OCDS release; defaults to `false` |

Filters are combined with **AND**. Within `keywords`, `keywordMode` controls whether any or all values must occur. CPV and buyer lists match when any supplied value matches.

### Output

Each default-dataset item is a normalized tender record:

```json
{
  "ocid": "ocds-e82gsb-583926",
  "releaseId": "ocds-e82gsb-583926-852220/2026-06-30-tender",
  "publishedAt": "2026-06-30T02:21:35+00:00",
  "tenderId": "583926",
  "title": "Tender title",
  "status": "active",
  "procurementMethod": "open",
  "category": "goods",
  "buyerName": "Contracting authority",
  "valueAmount": 107666.99,
  "valueCurrency": "EUR",
  "deadline": "2026-07-30T20:59:59+00:00",
  "cpvCodes": ["33112200", "33123200"],
  "lotCount": 6,
  "lots": [],
  "registerUrl": "https://app.eop.bg/today/583926",
  "sourceBundleUrl": "https://storage.eop.bg/open-data-2026-06-30/..."
}
```

The `RUN_SUMMARY` record in the default key-value store reports requested dates, loaded source bundles, emitted records, and source failures.

### API example

```bash
curl "https://api.apify.com/v2/acts/susurrant_cowl~bulgarian-public-procurement-monitor/runs?token=YOUR_APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"keywords":["строителство"],"onlyActive":true,"maxItems":100}'
```

Use your own Apify token and keep it private. The same Actor can be called from Apify clients, integrations, schedules, and MCP-compatible workflows.

### Official data source

- Open-data portal: https://app.eop.bg/today/reporting/open-data
- Daily public files: `https://storage.eop.bg/open-data-YYYY-MM-DD/`
- Format: Open Contracting Data Standard (OCDS) JSON

The Actor accesses public open-data files without logging in, bypassing access controls, or collecting private account data. It is an independent tool and is **not affiliated with or endorsed by the Bulgarian Public Procurement Agency or CAIS EOP**.

### Privacy and data handling

- No cookies, credentials, private profiles, or personal account data are collected.
- Input and output are stored using the retention and access settings of the Apify account running the Actor.
- `includeRaw` may increase dataset size because it preserves the complete public OCDS release.

### Limitations

- Daily source files may be published after the corresponding calendar day ends.
- A missing day is reported in `RUN_SUMMARY`; if every requested source fails, the run fails instead of silently returning an empty dataset.
- Source fields differ by notice type, so unavailable normalized fields are `null`.
- Value filters compare the published numeric amount without currency conversion.
- The earliest lot deadline is used as the tender-level deadline.
- Results depend on the completeness and accuracy of the official source.

### Support

For a reproducible issue, open the Actor's **Issues** tab and include the run URL, sanitized input, requested source dates, and the unexpected behavior. Never include Apify tokens or other credentials.

# Actor input Schema

## `startDate` (type: `string`):

First publication date to load, in YYYY-MM-DD format. Defaults to yesterday in UTC.

## `endDate` (type: `string`):

Last publication date to load, in YYYY-MM-DD format. Maximum range is 32 days.

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

Bulgarian or other text to match in tender titles, descriptions, buyers, and lot titles.

## `keywordMode` (type: `string`):

Require any keyword or all keywords to occur.

## `cpvPrefixes` (type: `array`):

Keep tenders with at least one CPV code beginning with any supplied prefix, such as 302.

## `buyerKeywords` (type: `array`):

Keep tenders whose buyer name contains any supplied value.

## `categories` (type: `array`):

Keep only goods, services, or works procurement categories.

## `minValue` (type: `number`):

Minimum published tender value, interpreted in the record's original currency.

## `maxValue` (type: `number`):

Maximum published tender value, interpreted in the record's original currency.

## `deadlineFrom` (type: `string`):

Keep tenders with an earliest lot deadline on or after this YYYY-MM-DD date.

## `deadlineTo` (type: `string`):

Keep tenders with an earliest lot deadline on or before this YYYY-MM-DD date.

## `onlyActive` (type: `boolean`):

Exclude releases whose tender status is not active.

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

Maximum number of normalized records written to the default dataset.

## `includeRaw` (type: `boolean`):

Attach the complete source OCDS release to each normalized record.

## Actor input object example

```json
{
  "keywords": [],
  "keywordMode": "any",
  "cpvPrefixes": [],
  "buyerKeywords": [],
  "categories": [],
  "onlyActive": true,
  "maxItems": 100,
  "includeRaw": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("susurrant_cowl/bulgarian-public-procurement-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("susurrant_cowl/bulgarian-public-procurement-monitor").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 '{}' |
apify call susurrant_cowl/bulgarian-public-procurement-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=susurrant_cowl/bulgarian-public-procurement-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulgarian Public Procurement Monitor",
        "description": "Search and filter official Bulgarian public procurement tenders by keywords, CPV codes, buyer, value, category, status, and deadlines via API.",
        "version": "0.1",
        "x-build-id": "60z3roUxFIJDsb2yq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/susurrant_cowl~bulgarian-public-procurement-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-susurrant_cowl-bulgarian-public-procurement-monitor",
                "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/susurrant_cowl~bulgarian-public-procurement-monitor/runs": {
            "post": {
                "operationId": "runs-sync-susurrant_cowl-bulgarian-public-procurement-monitor",
                "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/susurrant_cowl~bulgarian-public-procurement-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-susurrant_cowl-bulgarian-public-procurement-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "First publication date to load, in YYYY-MM-DD format. Defaults to yesterday in UTC."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Last publication date to load, in YYYY-MM-DD format. Maximum range is 32 days."
                    },
                    "keywords": {
                        "title": "Tender keywords",
                        "type": "array",
                        "description": "Bulgarian or other text to match in tender titles, descriptions, buyers, and lot titles.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordMode": {
                        "title": "Keyword matching",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "Require any keyword or all keywords to occur.",
                        "default": "any"
                    },
                    "cpvPrefixes": {
                        "title": "CPV code prefixes",
                        "type": "array",
                        "description": "Keep tenders with at least one CPV code beginning with any supplied prefix, such as 302.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "buyerKeywords": {
                        "title": "Buyer name keywords",
                        "type": "array",
                        "description": "Keep tenders whose buyer name contains any supplied value.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Procurement categories",
                        "type": "array",
                        "description": "Keep only goods, services, or works procurement categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "goods",
                                "services",
                                "works"
                            ]
                        },
                        "default": []
                    },
                    "minValue": {
                        "title": "Minimum tender value",
                        "type": "number",
                        "description": "Minimum published tender value, interpreted in the record's original currency."
                    },
                    "maxValue": {
                        "title": "Maximum tender value",
                        "type": "number",
                        "description": "Maximum published tender value, interpreted in the record's original currency."
                    },
                    "deadlineFrom": {
                        "title": "Deadline from",
                        "type": "string",
                        "description": "Keep tenders with an earliest lot deadline on or after this YYYY-MM-DD date."
                    },
                    "deadlineTo": {
                        "title": "Deadline to",
                        "type": "string",
                        "description": "Keep tenders with an earliest lot deadline on or before this YYYY-MM-DD date."
                    },
                    "onlyActive": {
                        "title": "Only active tenders",
                        "type": "boolean",
                        "description": "Exclude releases whose tender status is not active.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of normalized records written to the default dataset.",
                        "default": 100
                    },
                    "includeRaw": {
                        "title": "Include raw OCDS release",
                        "type": "boolean",
                        "description": "Attach the complete source OCDS release to each normalized record.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
