# Megaphone MCP

> Megaphone handles all your podcast publishing and advertising workflows. Use this server to manage networks, list podcasts, track episodes across a library, and handle full ad campaign placement details via natural conversation.

## Overview
- **Category:** content-management
- **Price:** Free
- **Tags:** podcast-hosting, ad-insertion, campaign-management, media-distribution, analytics

## Description

Look, forget those clunky dashboards and half-baked API calls. This **Megaphone MCP Server** hooks your AI client up right to your podcast publishing and ad management workflow. You're gonna manage everything—from the network structure all the way down to specific ad spots—just by chatting with your agent.

### Network Overview
When you wanna map out your whole operation, start by calling `list_networks`. That'll give you a clean list of every podcast network attached under your account. If you need deep metadata on just one of those networks, you use `get_network_details` to pull all the specifics for that single entity.

### Tracking Content Inventory
Once you know which networks you're working with, you gotta find the content inside. You can list every individual podcast belonging to a network using `list_podcasts`. For any specific show you pick out, you run `get_podcast` to grab all its detailed setup info. To see what episodes are actually available for that show, use `list_episodes`, which enumerates everything in the library. If you're hunting down something specific—maybe a keyword or a date range—you don't have to list 'em one by one; just hit up `search_episodes` and it crawls your entire catalog. Need the full data on one particular episode? You call `get_episode`, and that gives you all the deep details for that single piece of content.

### Managing Ad Placement and Campaigns
Running ads is half the job, right? To manage ad revenue, first, check out what campaigns are active or were run by calling `list_campaigns`. You can then figure out exactly where an ad needs to go on a specific episode using `list_ad_locations`; this shows all the available spots and locations for that one piece of content. When you need to track down existing placements, you use `list_orders` to retrieve records and details on every ad order placed in the network.

### Putting It All Together
This setup means your agent doesn't just pull data; it lets you build a full workflow. You can tell it to list all networks, then find all podcasts within Network A, get the episode count for Show B, and immediately check which ad spots are open on Episode 145. It processes that whole chain of commands conversationally. You're basically telling your agent: 'Check these ads, pull this data, cross-reference those episodes.' You don't have to juggle a dozen tabs; you just talk to your client and it handles the backend calls using all ten tools: `list_networks`, `get_network_details`, `list_podcasts`, `get_podcast`, `list_episodes`, `search_episodes`, `get_episode`, `list_campaigns`, `list_ad_locations`, `list_orders`. You'll get the whole picture of your publishing and ad revenue in one go.

## Tools

### get_episode
Retrieves detailed information about a single podcast episode.

### get_network_details
Fetches specific metadata and details for an entire podcast network.

### get_podcast
Gets detailed information about a single podcast show within a network.

### list_ad_locations
Lists the available ad spots and locations for a specific episode.

### list_campaigns
Retrieves all currently active or past ad campaigns associated with a network.

### list_episodes
Lists every available episode for a given podcast show.

### list_networks
Returns a list of all connected podcast networks under your account.

### list_orders
Retrieves records and details for ad orders that have been placed in the network.

### list_podcasts
Lists all individual podcasts belonging to a specific network.

### search_episodes
Searches across your entire podcast library for episodes matching keywords or criteria.

## Prompt Examples

**Prompt:** 
```
List all podcasts in my network.
```

**Response:** 
```
Retrieving podcasts... I found several active shows including 'Daily Tech News' and 'Marketing Insights'.
```

**Prompt:** 
```
Search for episodes about 'Artificial Intelligence'.
```

**Response:** 
```
Searching... I identified 3 episodes covering AI topics across your network.
```

**Prompt:** 
```
Show active ad campaigns for network ID 123.
```

**Response:** 
```
Querying campaigns... Network 123 has 5 active ad campaigns including 'Spring Sale' and 'New Product Launch'.
```

## Capabilities

### View Network Structure
List all associated podcast networks and retrieve detailed metadata for any single network.

### Track Content Inventory
Enumerate podcasts within a network, then list and search specific episodes across the entire library using tools like `list_episodes` or `search_episodes`.

### Manage Ad Placement
List active ad campaigns for a network and check available ad locations for any given episode.

### Process Ad Orders
Retrieve records of existing advertisement orders placed within the network.

## Use Cases

### Checking for Competitor Content
The content manager needs to know if any client network published an episode about 'Quantum Computing' last week. They ask their agent to run `search_episodes` across all networks, instantly receiving a list of matching episodes instead of running manual keyword searches in five different dashboards.

### Auditing Ad Placements
The ad sales rep needs to confirm what ads are scheduled for a new client launch. They use `list_orders` and then follow up with `list_ad_locations` on the target episode, getting precise details about inventory without leaving their chat window.

### Onboarding a New Client
A network director needs to see everything associated with a new client. They ask the agent to first use `get_network_details` then run `list_podcasts`, getting both high-level metadata and a list of every show name in two simple steps.

### Identifying Content Gaps
The editor wants to see if any podcast within the 'Tech' network has published more than 50 episodes. They ask their agent to run `list_podcasts` and then iterate through the results, checking each one with `list_episodes`.

## Benefits

- Check episode status fast. Instead of manually checking a dashboard, use `get_episode` or `search_episodes` to instantly verify if an episode is published or needs attention.
- Track every ad placement detail. Need to know where ads run? Run `list_ad_locations` on any given episode to see the exact spots available for monetization.
- Audit your entire portfolio. Use `list_networks` and `get_network_details` together to get a full, structured view of all connected client accounts in one go.
- Manage ad sales campaigns. The tool `list_campaigns` lets you see every active campaign running against the network without having to jump between tabs.
- Get complete content oversight. By combining `list_podcasts` and `list_episodes`, your agent builds a full map of what shows exist and how many episodes they have.

## How It Works

The bottom line is your AI client turns complex dashboard clicks into simple chat queries, pulling structured data from Megaphone automatically.

1. Subscribe to the Megaphone MCP Server and provide your API Token.
2. Your AI client uses specific tools (like `list_networks` or `get_podcast`) to gather data.
3. The agent processes that raw data—say, identifying all episodes matching 'AI'—and gives you a clean, conversational summary.

## Frequently Asked Questions

**How do I find all my client networks using Megaphone MCP Server?**
You use the `list_networks` tool. This quickly returns a list of every network connected to your account, giving you a full overview before you dive into specific content.

**Can I search episodes by keyword with Megaphone MCP Server?**
Yes, use the `search_episodes` tool. This function searches across your entire library and lets you find all relevant content using natural language queries, which is much better than manually listing everything.

**What tools do I need to check ad placement on an episode?**
You'll use `list_ad_locations` after getting the specific details of the show with `get_episode`. This pairing lets you see exactly where ads can run for that content.

**How do I check if a podcast is part of a larger network?**
First, use `list_networks` to get the master list. Then, use `list_podcasts` and specify the network ID to see which shows belong under that umbrella.

**How do I set up my Megaphone API Token before running `list_networks` using the Megaphone MCP Server?**
You must input your valid Megaphone API Token when subscribing to this server. Once authenticated, your AI client can run `list_networks` immediately, confirming full read access across all connected networks.

**When running `list_episodes`, does the Megaphone MCP Server handle large numbers of results or require pagination?**
The server automatically supports pagination for extensive episode libraries. Your AI client manages fetching subsequent data pages until it confirms all available episodes have been successfully retrieved.

**If I want to see a full history, how does `list_campaigns` show me ad campaigns in a network?**
The tool retrieves both active and historical campaign records for the specified network. You can tell your agent to filter these results by status or date range to narrow down what you're looking for.

**Before running `get_episode`, how do I ensure I have the correct Network ID and Podcast ID needed by the Megaphone MCP Server?**
You must first use `list_networks` to obtain the main network identifier. Then, run `list_podcasts` using that result to pinpoint the exact podcast identifier you need for any specific episode query.

**How do I find my Megaphone API Token?**
Log in to Megaphone, go to your Organization settings, and look for the API section to generate or copy your token.

**What podcast data can I access?**
You can access metadata for networks, podcasts, episodes, ad campaigns, and ad locations.

**Is my data secure?**
Absolutely. Your token is encrypted at rest and injected securely at runtime.