# Moldova Bank Exchange Rates (`blameless_rumor/moldova-bank-rates`) Actor

Live commercial cash and card exchange rates from MAIB, MICB, Victoriabank and the National Bank of Moldova (BNM). One normalized record per bank, currency pair and rate type.

- **URL**: https://apify.com/blameless\_rumor/moldova-bank-rates.md
- **Developed by:** [Valentin Perlog](https://apify.com/blameless_rumor) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## 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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Moldova Bank Exchange Rates

### What does Moldova Bank Exchange Rates do?

This actor scrapes **live commercial exchange rates** from the four largest banks in Moldova — **MAIB**, **MICB**, **Victoriabank** — plus the **National Bank of Moldova (BNM)** reference rate. For each (bank × currency pair × rate type) it returns one normalized JSON record with buy, sell, mid and spread fields, ready to plug into a comparison page, fintech app, or dashboard. There is no public aggregator API for Moldovan bank rates — this actor is the simplest way to get them.

Try a one-click run from the Apify Console, then export results as JSON, CSV, Excel or HTML, or call the Apify API to run on demand.

### Why use Moldova Bank Exchange Rates?

- **Commercial rates, not just the central-bank reference.** BNM publishes a daily reference rate; bank counter rates can differ by 1–4%.
- **Cash vs card rates as separate records.** Useful for buyers comparing in-branch tourist rates against card / transfer rates.
- **One JSON shape across all banks.** No per-bank quirks to handle downstream.
- **Apify-managed schedule, monitoring, proxy rotation.** Run every 6 hours out of the box; if a selector breaks, you'll see it in the run log.
- **Use cases:**
  - Remittance / fintech firms showing "where to exchange best."
  - Travel and booking platforms that price in MDL.
  - Personal-finance comparison sites in Moldova and Romania.

### How to use Moldova Bank Exchange Rates

1. Open the Actor in the Apify Console.
2. (Optional) Edit the input — by default all four banks and the five most common pairs are scraped.
3. Click **Start**.
4. When the run finishes (~5 s), open the **Dataset** tab.
5. Export as JSON / CSV, or call the Dataset API URL shown in the run summary.

### Input

The input is a small JSON object. All fields are optional and have defaults that produce ~25–30 records per run.

```json
{
    "banks": ["bnm", "maib", "micb", "victoriabank"],
    "pairs": ["EUR/MDL", "USD/MDL", "RON/MDL", "GBP/MDL", "CHF/MDL"],
    "rate_types": ["cash", "card"],
    "use_apify_proxy": true
}
````

See the **Input** tab for the full form-rendered schema.

### Output

Each record is one (bank × pair × rate type). You can download the dataset as JSON, CSV, Excel or HTML.

```json
{
    "pair": "EUR/MDL",
    "base": "EUR",
    "quote": "MDL",
    "bank": "maib",
    "bank_display_name": "Moldova Agroindbank (MAIB)",
    "rate_type": "cash",
    "buy": 20.10,
    "sell": 20.30,
    "mid": 20.20,
    "spread_pct": 0.99,
    "currency_unit": 1,
    "timestamp": "2026-05-06T20:17:46Z",
    "bank_updated_at": null,
    "source_url": "https://www.maib.md/en/curs-valutar",
    "available": true
}
```

### Data fields

| Field | Type | Notes |
|---|---|---|
| pair | string | "EUR/MDL" |
| base, quote | string | ISO 4217 codes |
| bank | string | Slug: bnm / maib / micb / victoriabank |
| bank\_display\_name | string | Human-readable bank name |
| rate\_type | string | "cash" or "card" |
| buy | number/null | Price the bank pays for 1 unit base |
| sell | number/null | Price the bank charges for 1 unit base |
| mid | number/null | (buy + sell) / 2 |
| spread\_pct | number/null | ((sell − buy) / mid) × 100 |
| currency\_unit | integer | Quote unit; e.g. 100 for JPY |
| timestamp | string (ISO 8601) | When the actor fetched the data |
| bank\_updated\_at | string/null | Bank's own publish time, if available |
| source\_url | string | Page or feed scraped |
| available | boolean | False if the bank does not quote that pair / type |

### Running via API

```bash
curl -X POST "https://api.apify.com/v2/acts/blameless_rumor~moldova-bank-rates/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"banks":["bnm","maib"],"pairs":["EUR/MDL"],"rate_types":["card"]}'
```

Returns the dataset items inline. For asynchronous runs use `/runs` and poll, or hook a webhook on completion.

### Pricing — How much does it cost to scrape Moldovan bank rates?

Pay-per-result, **$0.50 per 1000 records** ($0.0005 / record). A typical run with default input produces 25–30 records, so each run costs roughly **$0.013–$0.015**. Running every 6 hours for a month: about **$1.80**. The Apify free tier covers many runs.

### Tips

- Narrow `banks` and `pairs` to cut record count and cost.
- Schedule every 6 hours rather than every hour — bank rates do not move that fast.
- Use `use_apify_proxy: true` (the default) to avoid rate-limiting from any single IP.
- The actor is idempotent — re-running with the same input returns the latest snapshot, not historical data. For a time series, schedule + persist downstream.

### FAQ, disclaimers and support

> Exchange rates are scraped from public bank websites and may lag the bank's quoted rate by several minutes. Always verify with the bank before transacting. This actor is not affiliated with, endorsed by, or sponsored by any of the banks listed.

- **Selector broke?** Open an Issue on the actor's GitHub repo. Selector fixes typically ship within 24 hours.
- **Need another bank or pair?** Open an Issue describing the use case.
- **Custom integration?** Contact the maintainer via the Apify Store profile.

# Actor input Schema

## `banks` (type: `array`):

Which banks to scrape on this run.

## `pairs` (type: `array`):

Currency pairs in BASE/QUOTE form (always vs MDL in v1).

## `rate_types` (type: `array`):

Cash (in-branch) or card (transfer / account) rates.

## `use_apify_proxy` (type: `boolean`):

Route requests through Apify Proxy (datacenter). Recommended.

## Actor input object example

```json
{
  "banks": [
    "bnm",
    "maib",
    "micb",
    "victoriabank"
  ],
  "pairs": [
    "EUR/MDL",
    "USD/MDL",
    "RON/MDL",
    "GBP/MDL",
    "CHF/MDL"
  ],
  "rate_types": [
    "cash",
    "card"
  ],
  "use_apify_proxy": true
}
```

# Actor output Schema

## `rates` (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("blameless_rumor/moldova-bank-rates").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("blameless_rumor/moldova-bank-rates").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 blameless_rumor/moldova-bank-rates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=blameless_rumor/moldova-bank-rates",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Moldova Bank Exchange Rates",
        "description": "Live commercial cash and card exchange rates from MAIB, MICB, Victoriabank and the National Bank of Moldova (BNM). One normalized record per bank, currency pair and rate type.",
        "version": "0.1",
        "x-build-id": "NtzYPtDGdtcqbPgAY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/blameless_rumor~moldova-bank-rates/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-blameless_rumor-moldova-bank-rates",
                "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/blameless_rumor~moldova-bank-rates/runs": {
            "post": {
                "operationId": "runs-sync-blameless_rumor-moldova-bank-rates",
                "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/blameless_rumor~moldova-bank-rates/run-sync": {
            "post": {
                "operationId": "run-sync-blameless_rumor-moldova-bank-rates",
                "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",
                "required": [
                    "banks",
                    "pairs",
                    "rate_types"
                ],
                "properties": {
                    "banks": {
                        "title": "Banks",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which banks to scrape on this run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bnm",
                                "maib",
                                "micb",
                                "victoriabank"
                            ],
                            "enumTitles": [
                                "BNM (reference)",
                                "MAIB",
                                "MICB",
                                "Victoriabank"
                            ]
                        },
                        "default": [
                            "bnm",
                            "maib",
                            "micb",
                            "victoriabank"
                        ]
                    },
                    "pairs": {
                        "title": "Currency pairs",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Currency pairs in BASE/QUOTE form (always vs MDL in v1).",
                        "default": [
                            "EUR/MDL",
                            "USD/MDL",
                            "RON/MDL",
                            "GBP/MDL",
                            "CHF/MDL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "rate_types": {
                        "title": "Rate types",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Cash (in-branch) or card (transfer / account) rates.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cash",
                                "card"
                            ],
                            "enumTitles": [
                                "Cash",
                                "Card / transfer"
                            ]
                        },
                        "default": [
                            "cash",
                            "card"
                        ]
                    },
                    "use_apify_proxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy (datacenter). Recommended.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
