Pricing

from $2.00 / 1,000 results

Try for free

Go to Apify Store

RSS Feed Checker: Dead Episodes & Stale Feeds

Try for free

Directories point listeners at a podcast feed forever and never recheck it. Reports episodes whose audio answers 404, feeds that died or moved, and shows whose lastBuildDate is a year fresher than their newest episode - 14.2% of 300 sampled shows, all looking active to anything reading that date.

Pricing

from $2.00 / 1,000 results

Rating

0.0

(0)

Developer

Ai-Q Labs

Actor stats

Bookmarked

Total users

Monthly active users

23 days ago

Last modified

Categories

News

Social media

Automation

You can access the RSS Feed Checker: Dead Episodes & Stale Feeds programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "P1EvDXdDutaMYx5Md"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/aiqlabs~rss-feed-checker/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-aiqlabs-rss-feed-checker",
        "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/aiqlabs~rss-feed-checker/runs": {
      "post": {
        "operationId": "runs-sync-aiqlabs-rss-feed-checker",
        "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/aiqlabs~rss-feed-checker/run-sync": {
      "post": {
        "operationId": "run-sync-aiqlabs-rss-feed-checker",
        "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",
        "properties": {
          "shows": {
            "title": "Shows",
            "type": "array",
            "description": "Apple Podcasts show ids or URLs, in whatever form you have them. Both 1200361736 and https://podcasts.apple.com/us/podcast/the-daily/id1200361736 work.",
            "items": {
              "type": "string"
            }
          },
          "charts": {
            "title": "Apple charts",
            "type": "array",
            "description": "Audit the shows currently on these public Apple charts, for surveying rather than auditing a known list. Use top. Keyword search is deliberately not offered: itunes.apple.com/robots.txt names the search endpoint, and a chart is the better sample anyway.",
            "items": {
              "type": "string"
            }
          },
          "chartLimit": {
            "title": "Shows per chart",
            "minimum": 1,
            "maximum": 200,
            "type": "integer",
            "description": "How many shows to take from each chart.",
            "default": 25
          },
          "sampleSize": {
            "title": "Random sample from the directory",
            "minimum": 0,
            "maximum": 1000,
            "type": "integer",
            "description": "Draw this many shows from the sitemaps podcasts.apple.com advertises in its robots.txt. Use this to measure a slice of the directory rather than a list you already have. Leave at 0 to skip.",
            "default": 0
          },
          "country": {
            "title": "Storefront",
            "type": "string",
            "description": "Two-letter country code for the storefront the directory record is read from. A show can be listed in one storefront and absent from another.",
            "default": "us"
          },
          "episodesFromEachEnd": {
            "title": "Episodes to check from each end",
            "minimum": 0,
            "maximum": 25,
            "type": "integer",
            "description": "How many episodes to check the audio of, taken from the newest end and the oldest end of the feed. Newest is what a listener presses first; oldest is where rot appears years earlier. Set to 0 to skip audio entirely.",
            "default": 3
          },
          "checkOwnerAddress": {
            "title": "Check the owner address",
            "type": "boolean",
            "description": "Look at the domain behind the feed's owner email - the address Apple and Spotify send ownership verification to - and report whether it is registered and shaped to receive mail. Addresses at public mail providers are skipped. No mail server is ever contacted.",
            "default": true
          },
          "checkWebsite": {
            "title": "Check the show's website",
            "type": "boolean",
            "description": "Follow the site the feed links to and report where it ends up. One request per show.",
            "default": true
          },
          "dormantAfterDays": {
            "title": "Call a show dormant after (days)",
            "minimum": 30,
            "maximum": 7300,
            "type": "integer",
            "description": "How long without a new episode before it is worth noting. Default is 730 days. For context, 18.7% of a 300-show sample were past that, which is why this is a low-severity note rather than an alarm.",
            "default": 730
          },
          "veryDormantAfterDays": {
            "title": "And clearly finished after (days)",
            "minimum": 60,
            "maximum": 7300,
            "type": "integer",
            "description": "The point at which dormancy is reported at medium severity instead. Default is 1825 days (five years), which 5.8% of the same sample were past.",
            "default": 1825
          },
          "onlyIssues": {
            "title": "Only output shows with findings",
            "type": "boolean",
            "description": "Drop the rows that came back clean. Useful for a large sweep, though the clean rows are what tell you the run worked.",
            "default": false
          },
          "maxShows": {
            "title": "Maximum shows per run",
            "minimum": 1,
            "maximum": 2000,
            "type": "integer",
            "description": "Upper bound on how many shows are audited in one run, applied after charts and samples are expanded.",
            "default": 200
          },
          "maxConcurrency": {
            "title": "Concurrent shows",
            "minimum": 1,
            "maximum": 10,
            "type": "integer",
            "description": "How many shows to work on at once. Feeds and audio come from many different hosts, so this is gentle on each of them, but lower it if you are auditing many shows from one network.",
            "default": 5
          },
          "requestTimeoutSecs": {
            "title": "Request timeout (seconds)",
            "minimum": 5,
            "maximum": 180,
            "type": "integer",
            "description": "How long to wait for any single request before calling it unreachable.",
            "default": 30
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

RSS Feed Checker: Dead Podcast Episodes & Stale Feeds OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for RSS Feed Checker: Dead Episodes & Stale Feeds from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

RSS Feed Checker: Dead Episodes & Stale Feeds API in Python

RSS Feed Checker: Dead Episodes & Stale Feeds API in JavaScript

RSS Feed Checker: Dead Episodes & Stale Feeds API through CLI

RSS Feed Checker: Dead Episodes & Stale Feeds API

Podcast Episode Scraper: RSS, Audio URLs & Transcripts

themineworks/podcast-episode-scraper

Scrape podcast episodes from any RSS feed or by show name: title, description, duration, audio URL and publish date, plus the full transcript for shows that publish one. No API key, pay per episode.

The Mine Works

Podcast Scraper — Shows, Rankings & Episodes

hichemdev/podcast-scraper

Scrape podcasts by keyword: name, author, keyword rank, genre, episode count, artwork, RSS feed, plus recent episodes with duration and audio URL. No API key.

Hichem Ben Moussa

Podcast Transcription API — RSS feeds to episode transcripts

amanatools/podcast-transcription-api

Transcribe podcast episodes straight from an RSS feed. Pick the newest N per show, only episodes after a date, or only titles matching a phrase. Whisper runs inside the Actor — no API key. Show and episode metadata, text, SRT + VTT. Failed or silent episodes are never billed.

Dos

Apple Podcasts Scraper — Shows & Episodes

hipersoft/apple-podcasts-scraper

Search Apple Podcasts and scrape shows (name, host, RSS feed, genre, episode count, artwork) and their episodes (title, release date, duration, audio URL, description). Fast clean HTTP via the iTunes API, no setup. For podcast research, discovery and lead generation.

hiper soft

Podcast Scraper: Shows, Episodes & RSS Feeds

arman-bd/podcast-directory-scraper

Search Apple's podcast directory, then parse each show's RSS feed for full episode lists: titles, show notes, durations, audio URLs, season and episode numbers, and publish dates.

Arman Hossain

Fast Apple Podcasts Scraper - Charts by Country, RSS, Episodes

automia-admin/apple-podcasts-scraper

Scrape Apple Podcasts top charts by country, search shows by keyword and list episodes with direct audio URLs. Every show comes with its RSS feed, episode count and latest release date, so you can tell active shows from dead ones. No browser, no proxy, no API key.

Andrés Santiso

Apple Podcast Episode Watchlist Scraper

taroyamada/apple-podcast-episode-watchlist

Watch podcast RSS feeds for new public episodes and emit release rows with episode metadata, audio links, and source timestamps.

naoki anzai

🎙️ Podcast Episode Scraper - Feeds, Notes & Audio URLs

that_red_bird/podcast-episode-scraper

⚡ Turn any podcast RSS feed into structured episodes. ✅ Titles, show notes, audio file URLs, durations, seasons and episode numbers. ✅ Filter by keyword, date or minimum length. Also resolves YouTube video metadata.

mohamed alaya

Podcast Index Episodes Scraper

parseforge/podcastindex-episodes-scraper

Scrapes podcast episodes from Podcast Index by search query. Returns each episode as a flat row with title, description, audio URL, and publication date.