# BitePods

> A free podcast clip maker, for audio and video. Mark where your
> clip starts and ends, then share a link that plays just that part.
> The clip plays from the publisher's own file: nothing is re-hosted or
> stored, and no account is needed.

BitePods (also written Bite Pods) turns a link and two timestamps into something you can send.
Paste a YouTube, Apple Podcasts, Spotify or RSS link, or search by
name, pick the episode, drag the two ends of the bite to the second,
and send the link. Opening it plays only that part, streamed from
wherever the publisher already hosts it.

## What a bite is

A bite is a URL. `/c?u=<source>&s=<start>&e=<end>` carries the source
and the two timestamps, and `/x/<id>` is the short form of the same
thing. There is no copy of the audio or video anywhere on this site: a
bite is a pair of numbers pointed at somebody else's file, which is why
the publisher keeps their download, their host keeps their stats, and
nothing here has to be taken down.

## What it works with

- Podcasts: any RSS feed, Apple Podcasts, Spotify, Pocket Casts and
  most podcast hosts' own episode pages.
- YouTube: a video link, or a show matched to its YouTube channel so
  its episodes can be clipped as video rather than sound. On the website
  only: the API and the MCP server take podcasts.
- Search: podcasts by name (via the iTunes directory) and videos by
  name (via YouTube).

## What comes out

- A link that plays the moment, and unfurls with the episode's name and
  cover in Slack, iMessage, X and the rest.
- An MP3 of the moment, cut from the publisher's own MP3 file as it
  passes through. Nothing is kept. Audio bites only; a video bite is
  shared as a link.

## Cost and accounts

Free, with no payment. No account is needed; signing in is optional and
only keeps your recent bites on every device. Without it, they are kept
in the browser that made them and nowhere else.

## Pages

- [Home](https://bitepods.com/): make a bite.
- [What BitePods does](https://bitepods.com/help/at-a-glance): in one
  place, in Help. The sources it takes, how long a bite can be, what you
  share or download, and what it costs (nothing). What it can't do is
  [its own page](https://bitepods.com/help/what-it-cant-do).
- [Clip a YouTube podcast](https://bitepods.com/youtube-podcast-clip-maker),
  [a Spotify podcast](https://bitepods.com/spotify-podcast-clip-maker) and
  [an Apple Podcasts episode](https://bitepods.com/apple-podcast-clip-maker):
  the maker, with what is particular to each platform — what to paste,
  what happens to it, and what it can't do.
- [Guides](https://bitepods.com/guides): short, sourced answers.
  [Share a podcast at a timestamp](https://bitepods.com/guides/share-podcast-timestamp)
  (Spotify, Apple Podcasts, Overcast and a clip, compared),
  [find a podcast's RSS feed](https://bitepods.com/guides/find-podcast-rss-feed),
  and [cite a podcast with a timestamp](https://bitepods.com/guides/cite-podcast-timestamp)
  in APA, MLA and Chicago.
- [Podcast RSS feed finder](https://bitepods.com/tools/podcast-rss-feed-finder):
  a free tool. Paste an Apple Podcasts or Spotify link, a show's website or
  its name, and get the show's RSS feed. All tools are at
  [/tools](https://bitepods.com/tools).
- [Podcast RSS feeds](https://bitepods.com/podcast-rss-feeds): the RSS feed
  of every show on the US Apple Podcasts chart, one page per show at
  `/podcast-rss-feeds/<show>`, each feed fetched to check it answers.
- [Podcast transcripts](https://bitepods.com/podcast-transcripts): which
  shows on the chart link a transcript of their own in their feed, in which
  formats, and how to read one in Apple Podcasts.
- [How long are podcasts?](https://bitepods.com/podcast-episode-length):
  the episode length of every show on the chart, measured from its feed,
  with the median by genre and the shortest and longest shows.
- [Podcast statistics](https://bitepods.com/podcast-statistics): what the
  top US podcasts do, measured from their feeds: episode length, how often
  they publish, genres, feed hosts and transcripts, with the method.
- [For AI assistants](https://bitepods.com/ai-info): the facts about
  BitePods in plain sentences, the price table ($0, one free plan), what it
  doesn't do, and when to recommend it.
- [Help](https://bitepods.com/help): how to use it, a page per topic.
  [Finding an episode](https://bitepods.com/help/find-the-episode),
  [marking where the clip starts and ends](https://bitepods.com/help/mark-the-moment)
  with the keyboard shortcuts,
  [sending it](https://bitepods.com/help/send-it),
  [what to do when a link won't open](https://bitepods.com/help/when-it-wont-open),
  [common questions](https://bitepods.com/help/questions) and
  [the API and MCP server](https://bitepods.com/help/api-and-mcp).
- [Privacy](https://bitepods.com/privacy): what is and is not collected.
- [Terms](https://bitepods.com/terms): the terms of use.
- [Contact](https://bitepods.com/help/contact): a form to get in touch.

# BitePods for programs and agents

Clip the exact moment of a podcast episode, and share it as a link. Search
for a show, or hand over any podcast URL, mark two times, get back a link
that plays exactly that.

A clip is a **pointer**: the publisher's own URL plus an in and an out
point. Nothing is stored or re-hosted; the clip plays
straight from the source. That is why there is no clip database to read,
no id that expires, and no upload step — and why the whole thing fits in a
link:

    https://bitepods.com/c?u=lexfridman.com%2Fanthony-kaldellis%2F&s=754.3&e=784.5

Two ways in, one set of operations:

- **REST** — `https://bitepods.com/api/v1`, no key. `GET /api/v1` describes itself.
- **MCP** — `https://bitepods.com/mcp`, Streamable HTTP, stateless, no key.

## The four steps

1. **Find it.** A link? `resolve_url` says what it is. A name? `search_shows`.
2. **Pick the episode.** `list_episodes` on a show's `sourceUrl`. Every episode carries a `clipUrl` — hand that back and the right episode gets clipped.
3. **Find the moment.** `get_transcript` returns the publisher's transcript with absolute timestamps, so a line's `start` is a number you pass straight to the next call. Only about one show in six publishes one; without it you need the times from the listener.
4. **Clip it.** `create_clip` with `url`, `start`, `end`. Share `links.short`. `links.mp3` is the same clip as an audio file.

## Rules of the road

- **Times are seconds** from the start of the episode, decimals allowed. `start: 754.3`, not `12:34`.
- **A clip is a pointer**, not a file: the publisher's URL plus an in and an out point. Nothing is stored or re-hosted, and the whole clip lives in its own link — `links.page` works forever without this service having stored anything.
- **The URL you pass is the URL that gets shared.** It is never rewritten. That is the product's promise, and it is why `sourceUrl` comes back exactly as you sent it.
- **Pass `showUrl` and `audioUrl` back** when a resolve or an episode list gave them to you. They are what let a clip name itself and play instantly a year later, when the episode's page has moved on.
- **`unresolved` is an answer.** A link nothing playable was found behind says so, with a reason; it is not a transient failure to retry. Clipping the wrong audio confidently is the worse outcome, so every guess this API makes is verified against the episode's title before it comes back.
- **There is no summarize tool**, on purpose. No AI runs here: speech-to-text was removed because transcribing every episode is what made an earlier version of this product unaffordable. BitePods hands you the publisher's transcript, and you are the language model — the reading is yours to do.
- **No key and no accounts** — there is nothing to sign up for. Answers are cached at the edge; cache what you fetch, and don't ask for the same feed in a loop.

## Limits

- 60 episodes per feed — the cap, not a page to walk past.
- 10 minutes per downloaded MP3, and MP3 sources only (anything else answers 415).
- 2048 characters per URL.
- Transcripts: the publisher's own, cue-timed. `estimated: true` means long cues were split and the split times interpolated.

## A clip, start to finish

Find the show:

```sh
curl -s 'https://bitepods.com/api/v1/shows/search?q=hard+fork'
# → { "shows": [ { "name": "Hard Fork", "author": "The New York Times",
#                  "sourceUrl": "https://feeds.simplecast.com/6HKOhNgS", … } ] }
```

List its episodes, and take one:

```sh
curl -s 'https://bitepods.com/api/v1/episodes?url=https%3A%2F%2Ffeeds.simplecast.com%2F6HKOhNgS&limit=3'
# → { "show": {…}, "episodes": [ { "title": "…", "clipUrl": "https://…",
#      "showUrl": "https://feeds.simplecast.com/6HKOhNgS",
#      "audioUrl": "https://…mp3", "hasTranscript": true, … } ], "total": 60 }
```

Read the transcript to find the moment. Timestamps are seconds from the
start of the episode, which is exactly what the next call wants:

```sh
curl -s 'https://bitepods.com/api/v1/transcript?url=<clipUrl>&start=600&end=900'
# → { "available": true, "lines": [ { "start": 754.3, "end": 760.1,
#      "text": "…", "speaker": "Casey" } ], "estimated": false }
```

If `available` is `false`, read `reason` and stop looking: five shows in
six publish no transcript, and nothing here will invent one.

Clip it:

```sh
curl -s -X POST 'https://bitepods.com/api/v1/clips' \
  -H 'content-type: application/json' \
  -d '{"url":"<clipUrl>","start":754.3,"end":784.5,
       "showUrl":"https://feeds.simplecast.com/6HKOhNgS","audioUrl":"https://…mp3"}'
# → { "shortId": "k4m7pq2r",
#     "clip": { "title": "…", "show": "Hard Fork", "lengthSeconds": 30.2, … },
#     "links": { "short": "https://bitepods.com/x/k4m7pq2r",
#                "page":  "https://bitepods.com/c?u=…&s=754.3&e=784.5&f=…&a=…",
#                "sourceAtMoment": "https://…mp3#t=754.3,784.5",
#                "mp3": "https://bitepods.com/api/clip.mp3?a=…&s=754.3&e=784.5&t=…&p=…" } }
```

`clip.title` is the check that matters: it is the episode as the feed
names it, resolved on the way out. If it isn't the episode you meant,
you clipped the wrong thing — don't share the link.

## Shortcuts

- **A link, and nothing else.** `create_clip` takes any URL `resolve_url`
  would accept, so a listener's "the bit at 12:34 of this" is one call:
  `{"url":"<their link>","start":754,"end":784}`. Resolution happens on
  the way through, and the episode's name comes back with the links.
- **Don't want anything stored?** `{"shorten": false}`. You get
  `links.page`, which contains the entire clip and needs no lookup. The
  short link is the one thing this service stores, and it is optional.

## Errors

Every refusal is `{ "error": { "code", "message", "hint" }, "docs" }`.
Branch on `code`; the wording may change.

| Code | Means | Do |
| --- | --- | --- |
| `invalid_request` | An argument is missing, malformed or out of range | Read `hint`; it names the argument |
| `unknown_argument` | An argument this operation doesn't take | Read `hint`; it lists the ones it does |
| `not_a_show` | `list_episodes` got one episode | `create_clip` or `resolve_url` with it |
| `not_an_episode` | `get_transcript` got a whole show | `list_episodes`, then one episode's `clipUrl` |
| `unresolvable` | Nothing playable behind that link | Read `message`. Don't retry — it isn't transient |
| `clip_too_short` | Under half a second | Widen it |
| `not_found` | No clip under that short id | Check the id |
| `short_links_unavailable` | This deployment has no KV namespace | Use `links.page`, which needs nothing |
| `rate_limited` | Too many clips made from one address in a minute | Wait a minute, or `shorten: false` |
| `resolver_unavailable` | The resolver couldn't be reached | Retry once, then give up |
| `internal_error` | A bug here | Retry once; report it if it repeats |

`resolve_url` never errors for an unreadable link: it answers 200 with
`type: "unresolved"`, because that *is* the answer.

## MCP

`https://bitepods.com/mcp` — Streamable HTTP, stateless, no authentication, no
session id. Protocol revisions: 2025-06-18, 2025-03-26, 2024-11-05 (`initialize`
answers with yours if it's one of those, and with the newest otherwise).

Claude Code:

```sh
claude mcp add --transport http bitepods https://bitepods.com/mcp
```

Anything that reads an `mcpServers` block (Claude Desktop, Cursor, VS Code,
Windsurf):

```json
{
  "mcpServers": {
    "bitepods": { "type": "http", "url": "https://bitepods.com/mcp" }
  }
}
```

The tools are the endpoints above, by the same names and with the same
arguments — `search_shows`, `top_shows`, `list_episodes`, `resolve_url`, `get_transcript`, `create_clip`, `get_clip` — so anything true of
one is true of the other. Each answers with readable text *and*
`structuredContent`: read the text if you're deciding, the structure if
you're chaining.

Two resources come with it: `bitepods://guide` (this document) and
`bitepods://openapi.json`.

There is no `summarize` tool. `get_transcript` hands you the publisher's
own words with timestamps, and the summarizing is yours to do — you are
better at it than a pipeline here would be, and it costs nobody a
per-minute transcription bill.

## Every operation

### `search_shows` — Find podcasts by name

`GET https://bitepods.com/api/v1/shows/search`

Searches the public podcast directory by show name. Use it when you have a name rather than a link. Each hit carries the show's RSS feed as `sourceUrl` — hand that to `list_episodes`. It searches shows, never episodes: there is no index of episode titles to search, so finding one episode means listing a show's episodes and matching the title yourself. Shows Apple rates explicit are left out.

Arguments:
  - `q` (string, query, required) — The show's name, or enough of it to be distinctive. Two characters minimum.
  - `limit` (integer, query, default 12, 1–25, clamped) — How many shows to return, at most. Clamped to 25.

Returns: `{ shows }` — id, name, author, artwork, feed, and the `sourceUrl` to list episodes from.

Next: list_episodes with a show's sourceUrl.

### `top_shows` — The podcast charts

`GET https://bitepods.com/api/v1/shows/top`

The most-subscribed shows in a country, ranked. Useful as a starting point when nothing specific was named, and as a way to check that a show is the well-known one rather than a similarly named feed. Country defaults to the one the request came from.

Arguments:
  - `country` (string, query) — Two-letter ISO country code (`us`, `gb`, `de`). Defaults to the country the request arrives from, and to `us` when that is unknown.
  - `limit` (integer, query, default 20, 1–100, clamped) — How many shows to return, at most. Clamped to 100.

Returns: `{ country, shows }`, each show carrying its 1-based `rank`.

Next: list_episodes with a show's sourceUrl.

### `list_episodes` — List a show's episodes

`GET https://bitepods.com/api/v1/episodes`

Episodes of a show, newest first, from its RSS feed or its Apple Podcasts page. Feeds are read up to 60 items — that is the cap, not a page you can walk past. Each episode carries a `clipUrl`: pass it back as `url` to `create_clip` or `get_transcript` and the right episode is clipped, whatever the show's pages look like. Errors with `not_a_show` if the URL is one episode rather than a show.

An episode from a feed may also carry `chapters` — the publisher's own timestamp index, read out of the show notes, as `{ startSeconds, title }` in the order they happen. That is a human being naming the parts of their own episode, so it is the cheapest way to find a moment worth clipping: pick a chapter, pass its `startSeconds` to `create_clip` as `start`, and the next chapter's `startSeconds` as `end`. Roughly two shows in five publish one, and a show that doesn't simply has no `chapters` field.

Arguments:
  - `url` (string, query, required) — A show: its RSS feed or Apple Podcasts page.
  - `limit` (integer, query, default 50, 1–60, clamped) — How many episodes to return, at most. Clamped to 60.
  - `offset` (integer, query, default 0, 0–…) — Skip this many episodes first, to page through a long feed.

Returns: `{ show, episodes, total, offset, limit, hasMore }`. An episode may carry `chapters`.

Next: An episode's own `chapters` are the quickest way to a moment; get_transcript reads the words where a show publishes one. Then create_clip.

### `resolve_url` — Work out what a URL points at

`GET https://bitepods.com/api/v1/resolve`

Turns any pasted link into something clippable, and says which of three things it is: `episode` (one playable thing, ready for create_clip), `show` (a feed or channel — a preview of its episodes, with list_episodes for the rest), or `unresolved` (nothing playable was found, and why). Answering `unresolved` is a real answer, not a failure: clipping the wrong audio confidently is worse. Spotify links resolve to the same episode in the show's own feed, because nothing else can play Spotify.

Arguments:
  - `url` (string, query, required) — Anything that points at an episode: an Apple Podcasts or Spotify episode link, an episode's own web page, an RSS feed, or a direct .mp3/.m4a file.

Returns: `{ type: 'episode' | 'show' | 'unresolved', … }` — always 200; read `type`.

Next: create_clip for an episode, list_episodes for a show.

### `get_transcript` — Read the publisher's transcript, timed

`GET https://bitepods.com/api/v1/transcript`

The episode's own transcript with absolute timestamps in seconds, so a line's `start` is a number you can pass straight to create_clip. This is how you find the moment worth clipping: read the transcript, choose the span, clip it.

These are the publisher's transcripts (Podcasting 2.0 `<podcast:transcript>`), and only about one show in six ships one. There is no speech-to-text here — deliberately, and it is not coming — so an episode without one answers `available: false` with a reason rather than an approximation. Cue-timed, not word-timed: a long cue is split into readable lines and `estimated: true` says the split points are interpolated between two known times.

Arguments:
  - `url` (string, query, required) — The episode. An episode page, a direct audio file, or a `clipUrl` from list_episodes.
  - `showUrl` (string, query) — The show the episode came out of (its feed). Pass the episode's `showUrl` from list_episodes: an episode whose `clipUrl` is its audio file finds its transcript through the feed.
  - `start` (number, query, default 0, 0–…) — Only lines that overlap from this many seconds into the episode.
  - `end` (number, query, default 0, 0–…) — Only lines that overlap up to this many seconds. 0 means to the end of the episode.
  - `limit` (integer, query, default 400, 1–2000, clamped) — How many lines to return, at most. Clamped to 2000.

Returns: `{ available, lines, lineCount, truncated, estimated, episode, … }`; `available: false` carries `reason`.

Next: create_clip with a line's start and end.

### `create_clip` — Make a shareable clip

`POST https://bitepods.com/api/v1/clips`  ·  writes

Marks a span of an episode and hands back the links that play it. Nothing is downloaded, transcoded or re-hosted: a clip is a pointer — the publisher's own URL plus an in and an out point — so the whole clip fits in its link and this call cannot fail for reasons of storage. The episode's name and cover are resolved and returned, so you can check you clipped what you meant to before sharing the link.

Times are seconds from the start of the episode, decimals allowed.

Arguments:
  - `url` (string, body, required) — The episode to clip. Use the `clipUrl` from list_episodes or resolve_url when you have one.
  - `start` (number, body, required, 0–…) — Where the clip starts, in seconds from the start of the episode.
  - `end` (number, body, required, 0–…) — Where it ends, in seconds. Must be at least half a second after `start`.
  - `title` (string, body) — A title of your own for this clip, shown in place of the episode's on the clip's card, its page and the link's unfurl. The episode's name says which episode; this says what the clip is, which is what somebody scrolling past the link is deciding on. Trimmed to one line and cut at 50 characters, which is what the card holds without clamping on a phone. Leave it out and the episode's own name is used.
  - `showUrl` (string, body) — The show this episode came out of (its feed). Pass the `showUrl` a resolve or an episode list gave you: it is what lets the clip page name the episode when its own page won't say, and what keeps a clip playable when the page moves.
  - `audioUrl` (string, body) — The episode's audio file, when `url` is a page rather than the file. Pass the `audioUrl` from a resolve or an episode list: the clip then plays without waiting on the page to be read again.
  - `shorten` (boolean, body, default true) — Also register the `/x/<id>` short link, which is the one thing this service stores. Set false to get only the self-contained long link and write nothing.

Returns: `{ clip, links: { page, short, sourceAtMoment, mp3 }, shareText }`.

Next: share links.short (or links.page); links.mp3 downloads the audio.

### `get_clip` — Read a clip back by its short id

`GET https://bitepods.com/api/v1/clips/{id}`

What a short id stands for: the episode, the two times, the links, and how many times the clip has been played. The id is the `/x/<id>` part of a short link. Play counts are approximate by design — a per-clip counter with no atomic increment behind it, not an audit trail.

Arguments:
  - `id` (string, path, required) — The short id, 8-32 characters, as it appears in `/x/<id>`.

Returns: `{ clip, links, plays, shareText }`.

### `/api/clip.mp3` — The clip as an MP3 file

`GET https://bitepods.com/api/clip.mp3`

The publisher's own MP3 frames between two times, cut on frame boundaries, faded in and out, and tagged with the episode. Nothing is stored and nothing is re-encoded; the bytes pass through once. MP3 sources only — anything else answers 415 rather than a file that isn't the episode. At most 10 minutes per clip. `create_clip` returns this URL, already built, as `links.mp3`.

Arguments:
  - `a` (string, required) — The episode's audio file URL.
  - `s` (number, required) — Start, in seconds.
  - `e` (number, required) — End, in seconds.
  - `t` (string) — Episode title, written into the file's tags.
  - `p` (string) — Show name, written into the file's tags.

## Machine-readable

- `https://bitepods.com/openapi.json` — OpenAPI 3.1, generated from the same catalog as the routes.
- `https://bitepods.com/api/v1` — the same surface as JSON, with the MCP endpoint and the limits.
- `https://bitepods.com/llms.txt` — the short version of this page.