# Bosnia Public Procurement Contracts Scraper (`treasury_thoughts/bosnia-public-procurement-contracts`) Actor

Awarded public contracts from Bosnia and Herzegovina's official e-Nabavke (javne nabavke) open API as flat records: authority, winning supplier, value, CPV code and number of bidders. Filters, fresh data, scheduled monitoring.

- **URL**: https://apify.com/treasury_thoughts/bosnia-public-procurement-contracts.md
- **Developed by:** [Treasury Thoughts](https://apify.com/treasury_thoughts) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 contracts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Get **Bosnia and Herzegovina public procurement data** (e-Nabavke, *javne nabavke*) as clean, flat records: **who bought, who won, how much, what was bought (CPV code) and how many bidders competed.** The data comes straight from the official e-Procurement open API of the Public Procurement Agency of Bosnia and Herzegovina and is as fresh as the portal itself: new contracts appear within minutes.

The raw API is spread over 127 endpoints and needs six or more joins to connect a contract to its winner. This Actor does the joins for you and returns one ready-to-use row per awarded contract.

### What does Bosnia Public Procurement Contracts Scraper do?

It reads awarded contracts from the e-Nabavke open data API, adds the contracting authority, the winning supplier (or all consortium members), the lot, the main CPV code and the number of bidders, and saves one record per contract. You can filter by date, keyword, procedure type, contract type and value, and you can run it on a schedule to receive only new or updated contracts.

### What data can you extract?

| Group | Fields |
|---|---|
| Contract | `contractId`, `contractDate`, `contractValue`, `currency`, `lastUpdated` |
| Procedure | `procedureId`, `procedureNumber`, `procedureName`, `procedureType`, `contractType`, `awardCriterion` |
| Lot and CPV | `lotId`, `lotName`, `lotEstimatedValue`, `cpvCode`, `cpvDescription` |
| Authority | `authorityId`, `authorityName`, `authorityTaxNumber`, `authorityCity`, `authorityType`, `authoritySector`, `authorityRegion` |
| Winner | `winnerName`, `winnerTaxNumber`, `winnerCity`, `winnerCountry`, `winnerIsForeign`, `isConsortium`, `winners` (all members, lead first) |
| Competition | `bidderCount`, `offersReceived`, `singleBidder` |

### How to scrape Bosnia public procurement contracts

1. Click **Try for free** and pick a date range (default: last 30 days), plus an optional keyword such as `računar` (computers) or `vozila` (vehicles).
2. Press **Start**. A run of a few hundred contracts takes about a minute.
3. Open the **Output** tab and download the results as JSON, CSV or Excel, or read them through the API.

### What can you use Bosnia procurement data for?

- **Sell to the public sector:** see which authorities buy your product category (CPV code), at what prices and from whom.
- **Competitor and market analysis:** track who wins contracts by region, authority, category or value.
- **Due diligence and KYB:** check a supplier's public-contract history.
- **Risk and transparency research:** filter single-bidder awards (`singleBidder`) and consortia.
- **Monitoring:** schedule the Actor with `onlyNew` to receive only contracts added or changed since the last run.

### Input

| Field | Description |
|---|---|
| `dateFrom` / `dateTo` | Contract date range, `YYYY-MM-DD` (Bosnian local dates). Default: last 30 days |
| `keyword` | Text in the procedure title, in the notice language (for example `računar`, `vozila`, `lijekova`) |
| `procedureTypes` | Default: open, restricted and competitive-request procedures. Direct agreements are supported but off by default (they are about 85% of all records and mostly tiny) |
| `contractTypes` | `Goods`, `Services`, `Works`. Empty means all |
| `minValue` | Minimum contract value in BAM |
| `maxItems` | Cap on records returned. You are charged per record, so this is also your spending cap |
| `onlyNew` | Return only contracts added or updated since your last run. The first run uses the date range |

Example input:

```json
{
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "keyword": "vozila",
  "contractTypes": ["Services"],
  "minValue": 5000,
  "maxItems": 500
}
```

### Output example

One record per contract (abridged):

```json
{
  "contractDate": "2026-10-09",
  "procedureName": "Nabavka i sukcesivna isporuka lijekova",
  "procedureType": "OpenProcedure",
  "lotName": "Paracetamol, propafenon, ipratropij bromid +...",
  "authorityName": "JAVNA USTANOVA \"DOM ZDRAVLJA\" ZENICA",
  "winnerName": "LICENTIS D.O.O. SARAJEVO",
  "winnerCountry": "Bosnia and Herzegovina",
  "isConsortium": false,
  "contractValue": 1794.6,
  "currency": "BAM",
  "bidderCount": 1,
  "singleBidder": true,
  "cpvCode": "33690000-3"
}
```

### Why use this Actor instead of the portal or the raw API?

| | e-Nabavke website | Raw open API | This Actor |
|---|---|---|---|
| Winner next to each contract | Page by page | Needs 6+ joins across endpoints | One flat row |
| Bulk export | Manual | You write and maintain the code | CSV, JSON, Excel in one click |
| Filters by CPV, value, type, keyword | Limited | OData queries you build yourself | Simple input form |
| Monitoring new contracts | Manual checks | You build the sync | Schedule it with `onlyNew` |
| Private individuals | Shown | Present in raw data | Names withheld |

### How much does it cost to scrape Bosnia procurement data?

You pay per contract record saved to the dataset; the current price is shown on the **Pricing** tab. Set `maxItems` to cap what a run can cost. You are not charged for records you do not receive, and a small test run of 20 records costs only a few cents.

### Integrations and API access

Run it from the Apify API, schedule it, or connect the results to Google Sheets, Make, Zapier or n8n through the Apify integrations.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<ACTOR_ID>").call(run_input={"keyword": "računar", "maxItems": 100})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["contractDate"], item["winnerName"], item["contractValue"])
```

### FAQ

#### How fresh is the data?

New procedures appear in the source within minutes. Schedule the Actor with `onlyNew` for near-real-time monitoring.

#### Where does the data come from?

From the open data API of the e-Nabavke system (`open.ejn.gov.ba`), run by the Public Procurement Agency of Bosnia and Herzegovina.

#### Why are direct agreements off by default?

They are the vast majority of records and mostly very small. Add `DirectAgreement` to `procedureTypes` if you need them.

#### Can I search by winner name?

The source API does not support it, so filter the dataset after the run. Use `keyword`, dates, type and value to narrow the run itself.

#### Is the data complete?

The open dataset covers part of the data the Agency is obliged to publish, so this is not a complete register of every procurement in the country.

#### Something looks wrong or a field is missing?

Open an issue on the Actor page and describe the case.

### Related Actors

- [Moldova Public Procurement Tenders Scraper](https://apify.com/treasury_thoughts/mtender-actor): tenders, buyers and bidders with IDNO from Moldova's official MTender platform.
- [Moldova Company Financial Statements Scraper](https://apify.com/treasury_thoughts/depozitar-actor): official revenue, profit, assets and employees of Moldovan companies.

### Data notes

- **Source:** Public Procurement Agency of Bosnia and Herzegovina, e-Procurement open data (`open.ejn.gov.ba`). This Actor is independent and is not affiliated with or endorsed by the Agency.
- **No warranty:** data is provided as is and is not an official record. Verify anything important against the source before relying on it. You are responsible for using the data in line with the law that applies to you.
- **Respectful access:** requests are throttled to about two per second.
- **Dates:** `contractDate` is the calendar date in Bosnia and Herzegovina (Europe/Sarajevo).
- **Currency:** values are in Bosnian convertible marks (BAM). The API itself does not state the currency.
- **Bidders:** `bidderCount` is the number of bidders registered on the lot and is filled for nearly all records. `offersReceived` comes from the award notice and is empty when the notice has not been published yet.
- **Privacy:** names and identifiers of private individuals are never output; such winners appear as "Natural person (name withheld)".
- **Language:** titles and names are in the language of the original notices (Bosnian, Croatian, Serbian in Latin or Cyrillic).

# Actor input Schema

## `dateFrom` (type: `string`):

Earliest contract date (YYYY-MM-DD). Default: 30 days ago.

## `dateTo` (type: `string`):

Latest contract date (YYYY-MM-DD). Default: today.

## `keyword` (type: `string`):

Text search in the procedure title (language of the notice, e.g. Bosnian/Serbian/Croatian: 'računar', 'vozila').

## `procedureTypes` (type: `array`):

Which procedure types to include. Direct agreements are ~85% of all records and mostly tiny, so they are off by default.

## `contractTypes` (type: `array`):

Leave empty for all.

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

Only contracts worth at least this much.

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

Upper limit on records returned (you are charged per record).

## `onlyNew` (type: `boolean`):

Remembers where the previous run stopped and returns only contracts added or changed after that. The first run uses the date range.

## Actor input object example

```json
{
  "procedureTypes": [
    "OpenProcedure",
    "RestrictedProcedure",
    "CompetitiveRequest"
  ],
  "maxItems": 20,
  "onlyNew": false
}
```

# Actor output Schema

## `contracts` (type: `string`):

One record per awarded contract: authority, winner, value, CPV code, bidders.

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

Compact view: date, procedure, lot, authority, winner, value, bidders, CPV, type.

# 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 = {
    "procedureTypes": [
        "OpenProcedure",
        "RestrictedProcedure",
        "CompetitiveRequest"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("treasury_thoughts/bosnia-public-procurement-contracts").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 = {
    "procedureTypes": [
        "OpenProcedure",
        "RestrictedProcedure",
        "CompetitiveRequest",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("treasury_thoughts/bosnia-public-procurement-contracts").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 '{
  "procedureTypes": [
    "OpenProcedure",
    "RestrictedProcedure",
    "CompetitiveRequest"
  ],
  "maxItems": 20
}' |
apify call treasury_thoughts/bosnia-public-procurement-contracts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,treasury_thoughts/bosnia-public-procurement-contracts"
        }
    }
}
```

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/XqZxKK9d8BdtpEjdq/builds/I5dg7wxPdeaZj7w4j/openapi.json