# Bahrain Import Data API (`sourcing-data-studio/bahrain-import-data-api`) Actor

Unofficial Bahrain import data API: monthly non-oil imports of Bahrain by 8-digit HS code and country of origin, with value, weight, quantity and unit values. Data from the Bahrain Open Data Portal.

- **URL**: https://apify.com/sourcing-data-studio/bahrain-import-data-api.md
- **Developed by:** [Sourcing Data Studio](https://apify.com/sourcing-data-studio) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 64.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 import records

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

See what Bahrain imports, from where, and at what declared price, before you enter the market. Bahrain Import Data API returns the monthly non-oil imports of Bahrain by 8-digit HS code and country of origin from the Bahrain Open Data Portal: value in BHD and USD, weight, quantity and unit values. Use it to size demand and compare origins. You pay only for records saved.

Unofficial: not affiliated with or endorsed by the Information & eGovernment Authority or the Government of Bahrain.

Datasets provided by the Information & eGovernment Authority via www.data.gov.bh are governed by the Bahrain Open Government Data License available at www.nea.gov.bh/Documents/OpenDataLicense.pdf. To the fullest extent permitted by law, the government is not liable for any damage or loss of any kind caused directly or indirectly by the use or availability of the datasets or any derived analyses or applications. Datasets provided by the iGA via www.data.gov.bh are governed by the Terms of Use available at www.data.gov.bh/en/TermsOfUse.

Every record names its dataset and the time it was retrieved. Renaming, sorting, rounding, the two unit values and the three code levels (hs6, hs4, hsChapter) are done by this Actor. Any analysis or transformation of the data is ours and is not attributed to the Information & eGovernment Authority.

### What does Bahrain Import Data API do?

- Works as a Bahrain open data API for one topic: it reads the yearly import datasets of the Bahrain Open Data Portal for the years 2021 to 2026.
- Filters by HS code prefix (2 to 8 digits), by keyword in the English commodity description, by country of origin, by year and by month.
- Works as a Bahrain trade statistics API for products: ask for "8517" to get Bahrain imports by HS code for telephone sets, or for "smartphone" to find them by name.
- Computes two unit values for you: USD per kilogram and USD per unit.
- Adds `hs6`, `hs4` and `hsChapter`, the first 6, 4 and 2 digits of the commodity code, so that years with different 8-digit lines can still be grouped.
- Returns the newest period first and, inside a period, the largest value first. A low limit therefore gives you the most recent and biggest records.
- Removes exact duplicates and rejects incomplete records before they are saved.
- Charges one event per saved record. Failed requests, duplicates and invalid records are never charged.
- Asks the portal politely: one request at a time, at least a second apart, under its own name. If the portal refuses a request, the run stops and does not try another address.
- Writes a run summary with the source, the datasets, the licence statement, totals and failures to the key-value store.
- Works from Apify Console, the Apify API, n8n, Make and AI agents through the Apify MCP server.

### What data can you get with Bahrain Import Data API?

Use this Bahrain import data API to get Bahrain customs import data in the form the portal publishes it: one record per month, 8-digit commodity code and country of origin. It covers Bahrain HS code import statistics and Bahrain imports from China, India, Saudi Arabia and any other origin. Each row also carries `hs6`, `hs4` and `hsChapter`, which this Actor derives from the commodity code.

| Field | Type | Description |
|---|---|---|
| `year` | integer | Calendar year of the import period. |
| `month` | integer | Month of the import period, 1 (January) to 12 (December). |
| `period` | string | Import period as year and month, for example 2025-02. |
| `hsCode` | string | 8-digit commodity code (HS-based customs tariff code) as published by the portal. The 8-digit lines are renumbered between HS editions, so use hs6 as the key for a series over several years. |
| `hs6` | string | Computed by this Actor: the first 6 digits of hsCode, the HS subheading shared internationally. The stable key for a series over several years, because the 8-digit lines are renumbered between HS editions. Null when hsCode has fewer than 6 digits. |
| `hs4` | string | Computed by this Actor: the first 4 digits of hsCode, the HS heading. |
| `hsChapter` | string | Computed by this Actor: the first 2 digits of hsCode, the HS chapter, with its leading zero (for example 09). |
| `commodity` | string | Commodity description in English, as published. |
| `commodityArabic` | string, optional | Commodity description in Arabic, as published. |
| `originCountryCode` | string | Country of origin as a 2-letter ISO 3166-1 code, for example CN. |
| `originCountry` | string | Country of origin name in English, as published. |
| `valueBhd` | number | Declared import value in Bahraini dinar (BHD), rounded to 3 decimals. A few correction records are negative. |
| `valueUsd` | number | Declared import value in US dollars, as published, rounded to 2 decimals. A few correction records are negative. |
| `weightKg` | number, optional | Imported weight in kilograms, rounded to 6 decimals. |
| `quantity` | number, optional | Imported quantity in the statistical unit of the commodity, rounded to 6 decimals. |
| `unit` | string, optional | Statistical unit of the quantity as published, for example NO (number of items) or KG. |
| `unitValueUsdPerKg` | number, optional | Computed by this Actor: valueUsd divided by weightKg, rounded to 4 decimals. Null when weightKg is 0 or missing, or when the value is negative. |
| `unitValueUsdPerUnit` | number, optional | Computed by this Actor: valueUsd divided by quantity, rounded to 4 decimals. Null when quantity is 0 or missing, or when the value is negative. |
| `datasetId` | string | Id of the yearly dataset on the Bahrain Open Data Portal that the record comes from. |
| `source` | string | Source domain of the data. |
| `publisher` | string | Publisher of the data: Information & eGovernment Authority, Kingdom of Bahrain. |
| `retrievedAt` | string | ISO 8601 time when the record was retrieved. |

`unitValueUsdPerKg` and `unitValueUsdPerUnit` are not in the source. This Actor computes them as the declared USD value divided by the weight or the quantity. They are averages of declared values for the whole record, not market prices. `hs6`, `hs4` and `hsChapter` are the first 6, 4 and 2 digits of `hsCode`.

### How to use Bahrain Import Data API

1. Click **Try for free** on this page.
2. Enter one or more **HS commodity codes** (for example `8517`), or **Search keywords**. At least one of the two is required.
3. Optionally add **Countries of origin** as 2-letter codes (for example `CN`), the **Years** and the **Months**.
4. Set **Maximum import records**. The run stops as soon as that many records are saved.
5. Click **Start**. Results appear in the **Output** tab while the run is going.
6. Download the results as JSON, CSV or Excel, or read them through the API.

If you give both codes and keywords, a record must match a code and a keyword. Several codes, keywords or countries in one list are combined with OR.

### Input examples

#### Phones from china and india

```json
{
  "hsCodes": [
    "8517"
  ],
  "originCountries": [
    "CN",
    "IN"
  ],
  "years": [
    2025
  ],
  "months": [
    10,
    11,
    12
  ],
  "maxItems": 100
}
```

#### Keyword search two years

```json
{
  "searchQueries": [
    "smartphone"
  ],
  "years": [
    2024,
    2025
  ],
  "maxItems": 200
}
```

#### Unit values by origin three years

```json
{
  "hsCodes": [
    "85171300"
  ],
  "years": [
    2023,
    2024,
    2025
  ],
  "maxItems": 500,
  "feedback": "Example: please add a monthly total per origin country."
}
```

### Output example

These rows come from a real run of the quick-test example.

```json
[
  {
    "year": 2025,
    "month": 12,
    "period": "2025-12",
    "hsCode": "85171300",
    "hs6": "851713",
    "hs4": "8517",
    "hsChapter": "85",
    "commodity": "Smartphones",
    "commodityArabic": "أجهزة هاتف ذكية (سمارت فون)",
    "originCountryCode": "CN",
    "originCountry": "CHINA",
    "valueBhd": 13797873.86,
    "valueUsd": 36696473.02,
    "weightKg": 27434.266,
    "quantity": 59084,
    "unit": "NO",
    "unitValueUsdPerKg": 1337.6145,
    "unitValueUsdPerUnit": 621.0899,
    "datasetId": "import-1-2025",
    "source": "data.gov.bh",
    "publisher": "Information & eGovernment Authority, Kingdom of Bahrain",
    "retrievedAt": "2026-10-06T03:59:44.420Z"
  },
  {
    "year": 2025,
    "month": 12,
    "period": "2025-12",
    "hsCode": "85176290",
    "hs6": "851762",
    "hs4": "8517",
    "hsChapter": "85",
    "commodity": "OTHER ELECTRICAL APPARATUS FOR LINE TELEPHONY OR LINE TELEGRAPHY",
    "commodityArabic": "اجهزة اخرى كهربائية للهاتف ( تلفون ) او البرق (تلغراف) السلكيين",
    "originCountryCode": "CN",
    "originCountry": "CHINA",
    "valueBhd": 2362490.028,
    "valueUsd": 6283218.16,
    "weightKg": 33939.801,
    "quantity": 27725,
    "unit": "NO",
    "unitValueUsdPerKg": 185.1283,
    "unitValueUsdPerUnit": 226.6264,
    "datasetId": "import-1-2025",
    "source": "data.gov.bh",
    "publisher": "Information & eGovernment Authority, Kingdom of Bahrain",
    "retrievedAt": "2026-10-06T03:59:44.420Z"
  },
  {
    "year": 2025,
    "month": 12,
    "period": "2025-12",
    "hsCode": "85176220",
    "hs6": "851762",
    "hs4": "8517",
    "hsChapter": "85",
    "commodity": "OTHER APPARATUS FOR CURRENT LINES CONDUCTORS SYSTEMS OR DIGITAL LINES SYSTEMS",
    "commodityArabic": "أجهزة أخرى لانظمة خطوط التيار الناقل او لانظمة الخطوط الرقمية",
    "originCountryCode": "CN",
    "originCountry": "CHINA",
    "valueBhd": 329179.055,
    "valueUsd": 875476.21,
    "weightKg": 5856.244,
    "quantity": 6813,
    "unit": "NO",
    "unitValueUsdPerKg": 149.4945,
    "unitValueUsdPerUnit": 128.5008,
    "datasetId": "import-1-2025",
    "source": "data.gov.bh",
    "publisher": "Information & eGovernment Authority, Kingdom of Bahrain",
    "retrievedAt": "2026-10-06T03:59:44.420Z"
  }
]
```

### How much does Bahrain Import Data API cost?

| Event | You pay for | Free | Bronze | Silver | Gold |
|---|---|---|---|---|---|
| Import record | One monthly import record (commodity code, origin country, value, weight, quantity) saved to the dataset. Failed requests and invalid rows are never charged. | $0.002 | $0.002 | $0.0018 | $0.0016 |

Prices are per event. Your tier follows your Apify subscription plan.

On the Free tier, $0.002 per import record means:

- 100 import records cost $0.20.
- 1,000 import records cost $2.00.

Apify also charges a tiny start fee per run (apify-actor-start, $0.00005 per GB of memory). Failed requests, duplicates and invalid records are never charged. To cap your spending, set **Maximum cost per run** in the run options; the run stops cleanly when that budget is used.

### Use Bahrain Import Data API from the API, n8n, Make or an AI agent

#### Apify API

Run the Actor and get the import records in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourcing-data-studio~bahrain-import-data-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"hsCodes":["8517"],"originCountries":["CN","IN"],"years":[2025],"months":[10,11,12],"maxItems":100}'
```

#### n8n and Make

Use an HTTP request module with the same URL, method POST and a JSON body like the input examples above. Store your Apify API token as a credential, never in the workflow itself.

#### AI agents through the Apify MCP server

Connect your agent to the Apify MCP server and call `sourcing-data-studio/bahrain-import-data-api` with the same input. Agents can use the **Feedback for the developer** field to report missing fields or problems.

### For AI agents

- Minimal call: `{"hsCodes":["8517"],"maxItems":10}`. At the Free price, 10 records cost $0.02, plus Apify's start fee. Records that are not saved are never charged.
- Read these fields first: `period`, `hs6`, `originCountryCode`, `valueUsd` and `unitValueUsdPerKg`.
- Outcomes: the run status message says how many records were saved. The `RUN_SUMMARY` record in the run's key-value store has `listings`, one status per year (`ok`, `no-match`, `blocked`, `failed` or `stopped`), the failed requests and `stoppedBy` (`timeout`, `request-limit` or `refused`).
- Do not use it for exports, oil trade, importer names or current prices: the portal publishes monthly declared values of non-oil imports by product and origin, nothing more.
- Call it through the Apify MCP server as the tool `sourcing-data-studio/bahrain-import-data-api` or through the Apify API.

### Limits

- At most 10,000 import records per run. For more, run the Actor several times, for example one run per year or per group of HS codes.
- The portal allows anonymous requests up to a daily quota per address (the portal does not publish the number). A run needs about one request for each 100 records, plus one overview request per year and at least one request per month, so this is rarely a limit. The proxy is off by default for that reason: addresses of a shared proxy are used by many people and their quota can already be used up. A proxy is never used to get round a refusal. After HTTP 429 with a wait time of up to 60 seconds the Actor waits and asks again from the same address. When the quota is used up, or the portal refuses a request (HTTP 401, 403 or 407), the run stops, keeps the records already saved, charges nothing for the refused request and tries no other address. If the run summary reports HTTP 429, run again later, after the portal's daily quota resets.
- Years are 2021 to 2026. 2026 is a partial year that grows as the Authority publishes new months, and the newest months of any year may lag behind. Each year is a separate dataset on the portal, so a new year is added to this Actor only after the portal has published it (checked each January).
- The data covers non-oil imports as the portal publishes them. Values are declared values; they can contain a few correction records with negative values, which are kept. The unit values of such records are empty.
- Keywords match whole words and word beginnings in the English description ("smartphone" finds "Smartphones"). A misspelling finds nothing, and the portal does not search inside a word. HS codes are the more reliable filter.
- A run that reaches its timeout stops cleanly and keeps what it saved. The status message then says that the result is incomplete, and the run summary has `stoppedBy` set to `timeout` and the status `stopped` for the years that were not read to the end.
- Records are de-duplicated within a run, not across runs.
- Codes change between years. Each year is a separate dataset, and the 8-digit lines are renumbered between HS editions, so the same 8-digit code can describe another product in another year and a product can move to a new code. For a series over several years use `hs6`, the first 6 digits, as the stable key (`hs4` and `hsChapter` group more coarsely), and compare the descriptions of the years you join. `hs6` itself changes when a new HS edition starts: mobile phones are 851712 in 2021 and 851713 (smartphones) from 2022.
- The portal and its columns are maintained by the Authority and can change. The Actor reads the yearly datasets it knows, and shows a failed request in the run summary instead of guessing.

### FAQ

#### Which data does Bahrain Import Data API collect?

Only open statistical data published on the portal: month, HS commodity code, commodity description in English and Arabic, country of origin, import value in BHD and USD, weight, quantity and unit. It needs no login and no API key.

#### Which data is not collected?

No names of importers, companies or private individuals, no contact persons, phone numbers or email addresses, no exports and no oil trade. The Actor reads only the columns listed in the table above and ignores everything else in a record.

#### Can I use the data commercially?

The Bahrain Open Government Data License v1.0 allows sharing, adapting and commercial use of the datasets, if you state the source and the extraction date and make clear that your analysis is yours and not the Authority's. Each record carries `datasetId` and `retrievedAt`, and the run summary has an `attribution` field with the full text. Read the licence at www.nea.gov.bh/Documents/OpenDataLicense.pdf for the exact terms.

#### Is a program allowed to read the portal's API?

Yes. The portal's FAQ says you can access the data by connecting to it through the Application Programming Interface (API), and the licence allows commercialising the applications that you develop using the datasets. The portal's robots.txt, the standard file of its software platform, says Disallow: /api/ for all user agents except Googlebot. Those rules are meant for crawlers. This Actor does not crawl: it calls the documented records endpoint of six fixed datasets, one request at a time, under its own name. If the portal refuses a request or its daily quota is used up, the run stops; nothing is charged for the refused request, and records saved before it stay charged. If the Information and eGovernment Authority asks us to stop, we stop (licence clause 3.3(e)).

#### Why did my run return 0 records?

No record matched your codes, keywords, countries, years and months, or the portal did not answer or refused a request. The **Storage** tab holds the run summary with the months found for each year and every failed request. Nothing is charged in either case.

#### How are the unit values calculated?

`unitValueUsdPerKg` is `valueUsd` divided by `weightKg`, and `unitValueUsdPerUnit` is `valueUsd` divided by `quantity`, both rounded to 4 decimals. Weight and quantity are rounded to 6 decimals. A unit value is empty when `weightKg` or `quantity` in the same record is 0 or missing, or when the value is negative. The `unit` field tells you what one unit is, for example `NO` for a piece.

#### Can I schedule Bahrain Import Data API?

Yes. Save your input as a task and add a schedule in Apify Console, for example once a month after the new month is published.

### Feedback

Tell us what to add next in the **Feedback for the developer** input field, or open an issue in the **Issues** tab. Feedback is saved with the run summary.

# Changelog

This Actor's version history is a separate document: https://apify.com/sourcing-data-studio/bahrain-import-data-api/changelog.md

# Actor input Schema

## `hsCodes` (type: `array`):

The goods to look up, as HS code prefixes with 2 to 8 digits. A prefix matches every 8-digit commodity code that starts with it: "85" is all electrical machinery, "8517" is telephone sets and network apparatus, "85171300" is smartphones only. Write codes in quotes so leading zeros stay ("09" is coffee and tea). Dots, dashes and spaces are ignored, so 8517.13.00 works. A code that is already covered by a shorter code in the same list is dropped. Several codes are combined with OR. Use at most 30 codes. At least one of HS commodity codes or Search keywords is required; if you give both, a record must match a code AND a keyword.

## `searchQueries` (type: `array`):

Optional keywords matched against the English commodity description, for example "smartphone", "telephone sets" or "cotton t-shirts". The portal matches whole words and word beginnings, case-insensitive: "telephon" finds "telephone" and "smartphone" finds "Smartphones", but a misspelling finds nothing and the portal does not search inside a word. Several keywords are combined with OR. Use at most 10 keywords of up to 60 characters. At least one of HS commodity codes or Search keywords is required.

## `originCountries` (type: `array`):

Optional. Only records whose country of origin is one of these 2-letter ISO 3166-1 codes, for example "CN" (China), "IN" (India), "AE" (United Arab Emirates), "SA" (Saudi Arabia), "TR" (Turkey), "DE" (Germany). Leave empty for all origin countries. Codes are not case-sensitive. Use at most 40 codes.

## `years` (type: `array`):

Calendar years to read, as whole numbers from 2021 to 2026, for example \[2024, 2025]. The default is \[2025]. The portal publishes one dataset per year; 2026 is a partial year that grows as the Authority publishes new months, and the newest months of a year may lag behind. Results are returned newest period first.

## `months` (type: `array`):

Optional. Only these months of each selected year, as whole numbers from 1 (January) to 12 (December), for example \[11, 12]. Leave empty for all months. A month that the portal has not published yet is simply absent from the results.

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

Maximum number of import records to save and pay for in this run, across all years and months. Records are read newest period first and, inside a month, largest import value first, so a low limit gives you the most recent and biggest records. The run stops as soon as this many records are saved.

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

Off by default. The Bahrain Open Data Portal needs no key, no login and no proxy, and it gives each IP address a daily quota of anonymous requests (the portal does not publish the number). Addresses of a shared proxy are used by many people at once, so their quota can already be used up. A proxy is not a way round a refusal: after HTTP 429 the Actor waits and asks again from the same address, and when the quota is used up or the portal refuses a request (HTTP 401, 403 or 407) the run stops without trying another address.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried with exponential backoff. Connection errors count too. A retry after a refusal always leaves from the same address. Requests the portal rejects for good (HTTP 400 or 404) or refuses (HTTP 401, 403 or 407) are not retried, and neither is HTTP 429 with a used-up daily quota or with a wait time above 60 seconds. Failed requests are never charged.

## `debugLog` (type: `boolean`):

Print detailed debug messages to the run log.

## `feedback` (type: `string`):

Optional. Tell us which field, dataset or filter you need next, or what went wrong. It is saved with the run summary. Do not include personal data. AI agents may also use this field to report problems.

## Actor input object example

```json
{
  "hsCodes": [
    "8517"
  ],
  "originCountries": [
    "CN"
  ],
  "years": [
    2025
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3,
  "debugLog": 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 = {
    "hsCodes": [
        "8517"
    ],
    "originCountries": [
        "CN"
    ],
    "years": [
        2025
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourcing-data-studio/bahrain-import-data-api").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 = {
    "hsCodes": ["8517"],
    "originCountries": ["CN"],
    "years": [2025],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("sourcing-data-studio/bahrain-import-data-api").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 '{
  "hsCodes": [
    "8517"
  ],
  "originCountries": [
    "CN"
  ],
  "years": [
    2025
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call sourcing-data-studio/bahrain-import-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sourcing-data-studio/bahrain-import-data-api"
        }
    }
}
```

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/AT2NmDQYaQ9c7sdPY/builds/93y3ejUkBifqKmNkb/openapi.json