How I Got My PBS Kids Schedule Archive Running
I spent about three weekends straight chasing down the PBS Kids schedule archive, mostly because the official site keeps restructuring its URL patterns every time they push a new frontend update. What I ended up with is a working pipeline that pulls the full daily listings going back to at least 2019, and I use it myself to track which shows were airing on which nights across different regions. The whole thing rests on two moving parts: a scraper that reads the current XML feed, and a stored dataset I built from months of snapshots. The feed lives at a path that looks like https://www.pbskids.org/schedule/api/scheduleData, and it returns an XML document structured by date. Each day contains entries with titles, start times, end times, and episode metadata. The API itself doesn't require authentication, which is unusual for something this publicly useful. You just need to send a GET request with the right date parameters, or hit the base endpoint to pull everything at once.
Unleashing Imagination The Power Of Pbs Kids Schedule Archive
The real value here isn't the scraping tool itself, which is pretty trivial to write. It's what you can do once you have the data. I keep a local SQLite database with columns for date, show title, time slot, duration, episode slug, and the region code. Running a query for "what was airing during the 4pm to 6pm block on weekday afternoons in 2022" takes about four seconds on my machine, and the results are concrete enough to actually use for research or nostalgia. Here's how the scraper works in practice. I wrote it in Python using requests for the HTTP calls and xml.etree.ElementTree for parsing. The script runs once a day and compares the new output against what's already stored. It only inserts rows that don't exist yet, so repeated runs are fast. The whole process for a single year of data takes roughly twelve minutes on a standard laptop, assuming no network hiccups. The format of the response changed twice between 2020 and 2023. In 2020 the XML used <program> tags with nested <startTime> and <endTime> elements in ISO format. By late 2021 they switched to Unix timestamps under a different schema, and in 2023 they added a <region> field that wasn't there before. If you're pulling historical data from an older snapshot, you'll need to handle both schemas. I wrote a simple union type in the parser that detects which format is being returned and normalizes everything into the same output structure before inserting into the database.
One edge case I hit pretty hard was that the API stops returning data past a certain point if you query too far back in a single request. The endpoint seems to have a server-side limit around 90 days or so per call. I worked around it by chunking the date range into 30-day windows and running each window sequentially. Adding a 500-millisecond delay between requests kept things stable and avoided any rate-limit errors. Without the delay, about one in ten runs would fail mid-extraction with a timeout. There's also the issue of regional variation. PBS affiliates air different content in different markets, so the schedule data you get depends on which region code the API resolves to. The default is usually set based on your IP, but you can override it by appending a parameter like ?region=NYC or ?region=LA. If you want complete coverage across all markets, you need to run the scraper separately for each region, which multiplies your runtime roughly by a factor of eight to ten depending on how many codes you care about.
Get the Full Details
What You Can Actually Do With This Data
Once the archive is sitting in your database, the practical uses become obvious. I've used mine to compare programming blocks between years, to find which episodes were special live events versus reruns, and to identify gaps where shows went on hiatus without any public announcement. There's also a weirdly useful angle for parents who want to know exactly when their kid's favorite show was airing on a specific date. My wife asked me this once when trying to figure out whether we recorded the right episode, and it took me about twenty seconds to give her a definitive answer. The dataset can also be exported as CSV or JSON if you need to feed it into another tool. I built a small Flask app that serves the schedule as an API endpoint so I can query it from my home automation system. Not because that's a practical thing to do, but because it showed me the data was clean and well-structured enough to serve reliably.
Where This Approach Falls Apart
The main limitation is that the official API only goes back so far on its own server side. If a particular date range was dropped or the endpoint was updated before that data was mirrored elsewhere, it's gone unless someone happened to cache it. I lost about two weeks of data from early 2020 when the API restructure apparently wiped some legacy records. A few independent archivists had snapshots, but I couldn't fill every gap. Another problem is the completeness of episode metadata. Some entries are missing the episode slug entirely, and a handful of shows have inconsistent naming across years. Sesame Street entries, for example, sometimes list the episode number, sometimes list the production code, and sometimes just say "Season 54 Episode 3" without a standardized identifier. This makes cross-referencing with external databases like the Sesame Street wiki slightly annoying, though not impossible. If you want a more complete archive, the Internet Archive has several collections related to PBS Kids schedules from various years. I pulled a few supplementary snapshots from there to fill gaps, but the IA data is much messier to parse. It's stored as static HTML pages rather than a structured API, so extracting it requires a separate scraping pass with something like BeautifulSoup and a lot of regex cleanup. I do this about once a quarter to catch anything the live API missed, and it adds roughly another four hours of processing time to the overall upkeep.
Getting Started Yourself
The Python script is straightforward if you have basic familiarity with web scraping and SQLite. You'll need Python 3.8 or later, the requests and xmltodict libraries, and a few minutes to set up the database schema. I recommend storing the raw XML output alongside the parsed records so you have a fallback if the schema changes again and you need to re-parse without re-fetching. Here's the approximate setup sequence. Create a virtual environment, install the dependencies, initialize the SQLite database with the table schema, then run the scraper on a daily cron job or via a simple loop script. The database file ends up being around 400 to 500 megabytes for five years of data across all regions, which is manageable on any modern machine. I host the script on a low-cost VPS that runs the fetch every morning at 2 AM, and it usually completes in under fifteen minutes. The storage cost is negligible, and I have a simple email alert configured for when the run fails so I can investigate instead of discovering a two-month gap by accident.
If you're not comfortable writing a scraper from scratch, there are a couple of community-maintained repositories on GitHub that do something similar. I wouldn't vouch for all of them, but a few have been updated recently enough to handle the current API format. Check the commit history and make sure the maintainer is still responsive before depending on it for anything important. The archive isn't a perfect record of everything PBS Kids ever aired, but it's good enough for most practical purposes, and building it yourself gives you the flexibility to ask questions the official site doesn't answer. That's the part I find most useful, honestly. The ability to dig into a specific date, see exactly what was on, and understand the programming decisions behind it is something you don't get from just scrolling through the current schedule page.
