# Internet Radio Stations MCP Server (`mrbridge/internet-radio-mcp`) Actor

Internet radio MCP server for Claude, ChatGPT and Cursor. Search tens of thousands of stations from the Radio Browser directory by genre, country, language, codec or bitrate, see what is trending, find stations nearby or similar to one you like, and check whether a stream works.

- **URL**: https://apify.com/mrbridge/internet-radio-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## 📻 Internet Radio Stations MCP Server

Give Claude, ChatGPT, Cursor, VS Code or any MCP client a searchable directory of internet radio. This MCP server reads the Radio Browser community directory (tens of thousands of stations) through 14 read-only tools. They search and rank stations, open a full record with its stream URL, show recent stream checks, find stations close to a point or similar to another one, identify the station behind a stream URL and count what exists per genre or country. ChatGPT also gets its `search` and `fetch` pair.

Ask "find jazz stations in France that stream in AAC above 128 kbps and passed their last check" and your assistant calls `music_search_stations`. Back come matching stations, each with a stream URL and a homepage, its codec and bitrate, plus the outcome of its latest check, ready to open in your player.

### Quick start

1. Copy your Apify API token from [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge).
2. Point your MCP client at `https://mrbridge--internet-radio-mcp.apify.actor/mcp` with that token, as a Bearer header or as `?token=` in claude.ai and ChatGPT ([Connect](#connect) has every recipe).
3. Ask in plain language.

### What this server exposes

This server gives an AI assistant read-only access to the Radio Browser community directory of internet radio stations through 14 tools. It searches stations by name, genre tag, country, region, language, codec and bitrate, ranks them (most listened in the last 24 hours, most voted, trending, recently added or changed), opens the full record of a station with its stream URL and homepage, shows the recent checks of a stream, finds stations near a point or similar to a given station, identifies the station behind a stream URL, and counts stations per genre, country, region and language. The ChatGPT `search` and `fetch` pair finds stations by name or genre and returns one station record as text. Radio Browser is public and keyless, so you need no credential beyond your Apify token, and every answer names its source. The server does not cover recorded music catalogues (artists, albums, tracks) and plays no audio.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `music_search_stations` | Search radio stations | `tool-read` |
| `music_browse_stations` | Browse top, trending and new radio stations | `tool-read` |
| `music_get_station` | Get one radio station | `tool-read` |
| `music_get_station_checks` | Check whether a station stream works | `tool-action` |
| `music_find_stations_near` | Find radio stations near a place | `tool-read` |
| `music_find_similar_stations` | Find similar radio stations | `tool-action` |
| `music_find_station_by_stream_url` | Find the station of a stream URL | `tool-read` |
| `music_list_genres` | List radio genres and tags | `tool-read` |
| `music_list_countries` | List countries with radio stations | `tool-read` |
| `music_list_regions` | List regions of a country with radio stations | `tool-read` |
| `music_list_languages` | List languages of radio stations | `tool-read` |
| `music_get_directory_stats` | Get radio directory statistics | `tool-read` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-read` |

#### `music_search_stations`: Search radio stations

Use this when you need internet radio stations matching a name, a genre tag, a country, a region, a language, a codec or a minimum bitrate, for example jazz stations in France or AAC stations above 128 kbps. Do not use for rankings without a filter (music_browse_stations), places on a map (music_find_stations_near) or recorded music, albums or artists (not covered). Parameters, at least one filter: `name` (part of the name, e.g. "FIP"), `exact_name`, `tag` (e.g. "jazz"), `exact_tag`, `all_tags` (every tag must match, e.g. \["jazz","lounge"]), `country_code` (e.g. "FR"), `region` (e.g. "Bavaria"), `language` (e.g. "french" or "fr"), `codec` (e.g. "AAC", "MP3", "OGG", "FLAC"), `min_bitrate_kbps` (e.g. 128), `https_only`, `include_broken` (default false: stations whose last check failed are hidden), `sort` ("popularity" by listeners in the last 24 hours, default, "votes", "trending", "name", "bitrate", "recently_changed"), `limit` (1 to 50, default 10, at most 30 in detailed mode), `offset`, `response_format` ("detailed" adds coordinates, check times, favicon and all tags). Each station comes with its station_id, stream URL, homepage and radio-browser.info page.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `name` | string | no | `"FIP"` |
| `exact_name` | boolean | no | `false` |
| `tag` | string | no | `"jazz"` |
| `exact_tag` | boolean | no | `true` |
| `all_tags` | array of string | no | `["jazz","lounge"]` |
| `country_code` | string | no | `"FR"` |
| `region` | string | no | `"Bavaria"` |
| `language` | string | no | `"french"` |
| `codec` | string | no | `"AAC"` |
| `min_bitrate_kbps` | integer | no | `128` |
| `https_only` | boolean | no | `true` |
| `include_broken` | boolean | no | `false` |
| `sort` | "popularity" or "votes" or "trending" or "name" or "bitrate" or "recently_changed" | no | `"popularity"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ stations[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

#### `music_browse_stations`: Browse top, trending and new radio stations

Use this when you need a ranking of internet radio stations: the most listened in the last 24 hours, the most voted, the trending ones (by the click trend Radio Browser reports) or the recently added or changed ones, worldwide or for one country, genre or language. Do not use for a name or several combined filters (music_search_stations) or stations near a place (music_find_stations_near). Parameters: `by` ("most_listened" default, "most_voted", "trending", "recently_changed"), `country_code` (e.g. "BR"), `tag` (e.g. "techno"), `language` (e.g. "spanish" or "es"), `limit` (1 to 50, default 10, at most 30 in detailed mode), `offset`, `response_format`. Stations whose last check failed are left out.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `by` | "most_listened" or "most_voted" or "trending" or "recently_changed" | no | `"trending"` |
| `country_code` | string | no | `"FR"` |
| `tag` | string | no | `"techno"` |
| `language` | string | no | `"french"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ stations[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

#### `music_get_station`: Get one radio station

Use this when you need everything about one internet radio station: stream URL (resolved and as submitted), homepage, favicon, country, region, languages, all tags, codec, bitrate, HLS, online status, last check and change times, votes, listeners in the last 24 hours, coordinates. Do not use for finding stations (music_search_stations) or the history of its stream checks (music_get_station_checks). Parameter: `station_id` (the UUID from another tool, e.g. "960e57c5-0601-11e8-ae97-52543be04c81", or a radio-browser.info station page URL).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `station_id` | string | yes | `"960e57c5-0601-11e8-ae97-52543be04c81"` |

Returns `{ station, next_steps[], attribution }`. Upstream: Radio Browser. Cache: hourly (1 hour). Read-only.

#### `music_get_station_checks`: Check whether a station stream works

Use this when you need to know whether an internet radio stream has been working: the recent online checks of one station, newest first, with a summary (checks that passed and failed, last success, last failure, check servers). Radio Browser checks stations from several check servers and keeps up to 30 days of results, sometimes only a few checks. Do not use for the station record itself (music_get_station). Parameters: `station_id` (UUID, e.g. "960e57c5-0601-11e8-ae97-52543be04c81"), `limit` (1 to 30, default 10), `offset`, `response_format` ("detailed" adds the resolved stream URL, server software, sampling rate and check duration).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `station_id` | string | yes | `"960e57c5-0601-11e8-ae97-52543be04c81"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ station, summary, checks[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: hourly (1 hour). Read-only.

#### `music_find_stations_near`: Find radio stations near a place

Use this when you need internet radio stations located near a point, nearest first, for example local stations around a city. Only stations that publish coordinates are found. Do not use for a whole country or region (music_search_stations with country_code or region). Parameters: `latitude` (-90 to 90, e.g. 48.8566), `longitude` (-180 to 180, e.g. 2.3522), `radius_km` (1 to 1000, default 50), `tag` (optional genre, e.g. "jazz"), `limit` (1 to 50, default 10, at most 30 in detailed mode), `offset`, `response_format`. The 200 most listened stations within the radius are ranked by distance, each with `distance_km`.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `latitude` | number | yes | `48.8566` |
| `longitude` | number | yes | `2.3522` |
| `radius_km` | number | no | `50` |
| `tag` | string | no | `"jazz"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ stations[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

#### `music_find_similar_stations`: Find similar radio stations

Use this when you need internet radio stations like a given one: stations sharing its most widely used genre tag, ranked by the number of shared tags, then by listeners, by default in the same country. Do not use for stations by name or by free filters (music_search_stations). Parameters: `station_id` (UUID, e.g. "960e57c5-0601-11e8-ae97-52543be04c81"), `same_country` (default true), `same_language` (default false), `limit` (1 to 30, default 10), `offset`, `response_format`. Each result lists its `shared_tags`. Generic tags such as "music" or "radio" are ignored.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `station_id` | string | yes | `"960e57c5-0601-11e8-ae97-52543be04c81"` |
| `same_country` | boolean | no | `true` |
| `same_language` | boolean | no | `false` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ source, stations[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

#### `music_find_station_by_stream_url`: Find the station of a stream URL

Use this when you have an internet radio stream URL (from a playlist file, a player or a log) and need the station it belongs to. Only an exact URL match counts. Do not use for station names or web pages (music_search_stations). Parameters: `stream_url` (http or https, e.g. "http://stream.example.com/mp3_128"), `response_format` ("detailed" adds coordinates, check times and all tags). Returns up to 20 stations and the number of matches.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `stream_url` | string | yes | `"http://stream.example.com/mp3_128"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ stations[], match_count, notice, next_steps[], attribution }`. Upstream: Radio Browser. Cache: hourly (1 hour). Read-only.

#### `music_list_genres`: List radio genres and tags

Use this when you need the genre and topic tags used by internet radio stations, with the number of working stations for each, for example how many stations play techno or which jazz sub-genres exist. Do not use for the stations themselves (music_search_stations with `tag`). Parameters: `name_contains` (e.g. "jazz"), `min_stations` (default 1, e.g. 10 to skip rare tags), `limit` (1 to 100, default 25), `offset`, `response_format` ("detailed" adds cache information). Without name_contains, the 1,000 most used tags are listed. Tags are free text chosen by the community, so spellings vary.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `name_contains` | string | no | `"jazz"` |
| `min_stations` | integer | no | `10` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ genres[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: daily (1 day). Read-only.

#### `music_list_countries`: List countries with radio stations

Use this when you need the countries that have internet radio stations, with their ISO code and number of working stations, or the code of a country before filtering by it. Do not use for regions inside a country (music_list_regions) or the stations themselves (music_search_stations). Parameters: `name_contains` (part of the English name or the code, e.g. "united"), `sort` ("stations" default or "name"), `limit` (1 to 250, default 25), `offset`, `response_format` ("detailed" adds cache information).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `name_contains` | string | no | `"united"` |
| `sort` | "stations" or "name" | no | `"stations"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ countries[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: daily (1 day). Read-only.

#### `music_list_regions`: List regions of a country with radio stations

Use this when you need the regions or states of one country that have internet radio stations, with the number of working stations for each, for example before searching the stations of Bavaria. Region names are free text from the directory, so one region can appear under several spellings. Do not use for countries (music_list_countries). Parameters: `country_code` (required, e.g. "DE"), `name_contains` (e.g. "berlin"), `limit` (1 to 100, default 25), `offset`, `response_format` ("detailed" adds cache information).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `country_code` | string | yes | `"FR"` |
| `name_contains` | string | no | `"berlin"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ country, regions[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: daily (1 day). Read-only.

#### `music_list_languages`: List languages of radio stations

Use this when you need the languages spoken on internet radio stations, with the number of working stations for each and the ISO 639 code when known. Do not use for the stations themselves (music_search_stations with `language`). Parameters: `name_contains` (part of the English name, e.g. "german"), `sort` ("stations" default or "name"), `limit` (1 to 100, default 25), `offset`, `response_format` ("detailed" adds cache information).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `name_contains` | string | no | `"german"` |
| `sort` | "stations" or "name" | no | `"stations"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ languages[], pagination, next_steps[], attribution }`. Upstream: Radio Browser. Cache: daily (1 day). Read-only.

#### `music_get_directory_stats`: Get radio directory statistics

Use this when you need the size of the Radio Browser directory: stations, broken stations, tags, languages, countries, listener clicks in the last hour and day, and optionally the most used audio codecs with their station counts. Do not use for per-country or per-genre counts (music_list_countries, music_list_genres). Parameter: `include_codecs` (default false, e.g. true).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `include_codecs` | boolean | no | `true` |

Returns `{ directory, codecs[], next_steps[], attribution }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

#### `search`: Search

Use this when ChatGPT needs to find internet radio stations by name or genre in the Radio Browser directory. Do not use for recorded music, artists or albums (not covered), or for filters by country, language or bitrate (the prefixed music\_ tools). Parameter `query` (string), e.g. "jazz" or "BBC". Returns up to 10 working stations, the most listened first, with their station UUID as id.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"jazz"` |

Returns `{ results[], notices[] }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs the full record of one station returned by search, as text: stream URL, homepage, country, languages, tags, codec, bitrate, online status and popularity. Do not use for ids that did not come from search. Parameter `id` (a station UUID from search), e.g. "960e57c5-0601-11e8-ae97-52543be04c81".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"960e57c5-0601-11e8-ae97-52543be04c81"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: Radio Browser. Cache: intraday (5 minutes). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--internet-radio-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http internet-radio "https://mrbridge--internet-radio-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "internet-radio": {
      "type": "http",
      "url": "https://mrbridge--internet-radio-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--internet-radio-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add Internet Radio Stations MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Internet%20Radio%20Stations%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--internet-radio-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--internet-radio-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "internet_radio",
  "server_url": "https://mrbridge--internet-radio-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--internet-radio-mcp.apify.actor/mcp",
      "name": "internet-radio",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "internet-radio"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/internet-radio-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use this server

- **Filters that combine.** Mix genre tag, country or region, language, codec, minimum bitrate and HTTPS in one search, sorted by listeners, votes or name.
- **Know before you press play.** Several check servers test each stream: see how often it passed or failed lately, and when it last worked.
- **Discovery beyond search.** Stations near a point ranked by distance, and stations like one you enjoy, ranked by shared genre tags.
- **Reverse lookup.** Paste a stream URL from a playlist or a log and get the station behind it.
- **Directory-wide numbers.** How many stations exist per genre or country, down to regions and languages, and which codecs dominate.
- **Links only.** Nothing is played, recorded or hosted here. Audio stays with its broadcasters.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Attribution.** Each answer carries an `attribution` block. Radio Browser places its data in the public domain and asks for no credit, so the credit line is a courtesy. This server is not affiliated with or endorsed by Radio Browser.
- **Third-party streams.** Stream URLs and homepages point to the broadcasters. This server returns links only: it never plays, records or hosts audio. Whether you may play or rebroadcast a stream depends on the broadcaster and on the rules where you are. The fee for this server pays for the service (hosting, caching, normalisation), not for a licence on any stream.
- **Community data.** Anyone can add a station, so names, tags, languages, regions and coordinates can be wrong, misspelled or missing. Genre tags and region names are free text, and one genre or region can appear under several spellings.
- **Working stations.** Radio Browser re-checks each stream regularly: on 2026-10-13, every station read had been checked within the previous 2 days. Stations whose last check failed are hidden unless you ask for them, a stream can stop working between two checks, and stations that have not worked for 6 days are removed from the directory, so a `station_id` can disappear.
- **Popularity.** "Most listened" counts the plays recorded by apps that use Radio Browser in the last 24 hours. It is not an audience measurement.
- **Paging.** Radio Browser does not report result counts, so `total` is a lower bound for searches and rankings, with `has_more` and `next_offset` to continue. A page is shortened when its rows would make the answer too large, and says so. Rankings can shift between two pages.
- **Nearby stations.** Only stations that publish coordinates are found. The 200 most listened stations within the radius are ranked by distance.
- **Freshness and load.** Radio Browser documents no rate limit. This server keeps to 2 requests per second per instance and caches answers: 5 minutes for station lists, 1 hour for station records and checks, 1 day for genres, countries, regions and languages. Radio Browser runs several federated servers: when one fails, the next one answers. When all of them fail, an older cached copy can be served, marked `stale` in the `cache` block.
- **Not covered.** Artists, albums, tracks, lyrics, charts and audio playback.

### Data terms

Station records come from the Radio Browser community directory (https://www.radio-browser.info), whose data is in the public domain. No credit is required, though every answer keeps one as a courtesy.

Every stream URL, homepage or favicon points to a third-party broadcaster, who keeps all rights in its programmes, its name and its logo. This server returns links only. It never plays, records, hosts or rebroadcasts audio, and its fee pays for the service (hosting, caching, normalisation), not for a licence on any stream. Before you play a stream in a public place or inside a product, check the broadcaster's terms and the rules where you operate.

To report a station link that should not be listed, open an issue on the [Issues tab](https://apify.com/mrbridge/internet-radio-mcp/issues?fpr=mrbridge).

### Use cases

- **Listening assistants.** Ask for a station that fits a mood, a language you are learning or a city you miss, and get a stream URL to open.
- **Radio and player apps.** Developers prototype station search, "near me" and "similar stations" features with an AI agent before writing their own client.
- **Playlist maintenance.** Find out whether the entries of an M3U file or a player config still work, and identify unknown URLs.
- **Market overviews.** Count stations by genre, language or region, for example how many working stations play techno in Germany.

### FAQ

#### Does it play music, or know artists and albums?

No to both. It hands your own player links to broadcasters' streams and homepages, and it holds stations only, with no recorded-music catalogue.

#### How fresh is the station data?

Radio Browser tests streams on a rolling basis, so the latest result can be a few days old, and stations failing for 6 days leave the directory. A feed can die between two tests, so glance at the latest result before relying on it.

#### Is the data reliable?

Anyone can add a station, so a name, a tag or a position on the map can be wrong or misspelled. "Most listened" counts plays from apps that use the directory: it is not an audience measurement.

#### What does a call cost?

Each successful tool call is one event, at the price shown on the [Pricing tab](https://apify.com/mrbridge/internet-radio-mcp/pricing?fpr=mrbridge) for your Apify plan: `tool-action` for `music_get_station_checks` and `music_find_similar_stations`, `tool-read` for every other tool. Paid Apify plans get lower prices. On the free plan, a read costs $0.005 and an action $0.01, so 100 reads come to $0.50 in events. On top of that, your Apify account pays the platform usage of your own Standby run while the server is up, idle minutes included. Errors are never charged, and `maxTotalChargeUsd` caps what one run can spend.

#### Why is the first call slower?

The first call after a quiet period starts a new Standby run on your Apify account, which takes a few seconds. Then it answers quickly, and it shuts down after about 5 idle minutes.

#### Is this server affiliated with Radio Browser?

No. It reads their public API, and Radio Browser does not endorse it.

#### Your feedback

Found a bug or a station link that should not be listed? Tell us on the [Issues tab](https://apify.com/mrbridge/internet-radio-mcp/issues?fpr=mrbridge).

More MCP servers, scrapers and data studies from the same team: [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.2: pricing events tool-read and tool-action
- 0.1.1: fixes from the first live capture: regions are read for the requested country only (small countries no longer come back empty), similar stations match the station's most widely used genre tag, web addresses no longer appear as languages or genres, and the trending and stream check descriptions follow what Radio Browser reports
- 0.1.0: initial build (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--internet-radio-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--internet-radio-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/internet-radio-mcp").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 = { "mcpEndpoint": "https://mrbridge--internet-radio-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/internet-radio-mcp").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 '{
  "mcpEndpoint": "https://mrbridge--internet-radio-mcp.apify.actor/mcp"
}' |
apify call mrbridge/internet-radio-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/internet-radio-mcp"
        }
    }
}
```

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/QFElDexzR1vr4TOOm/builds/5oYhgP3a0cIYZbe3U/openapi.json