The Big Decision: Why I Even Bothered with a Timeline
You know, people always ask why I spend time pulling timelines for games that happened ages ago. “Just check the final score,” they say. But I needed proof. I needed the cold, hard, minute-by-minute truth. I was in this stupid office fantasy league, right? And this Birmingham vs Peterborough game came up. Someone—let’s just call him Gary, because that’s his name—swore blind that the critical substitution that led to the third goal happened before the 70th minute. I said no way, it was 75 minimum. It became a whole thing. A stupid, petty argument that ended with a $50 bet I wasn’t ready to lose. So I decided I had to go deep. I wasn’t trusting some glossy sports site summary; I needed the raw log.
My goal wasn’t to build some sophisticated database. I just wanted the simple facts, laid out cleanly, exactly when they happened. I wanted to see the flow of the game, not just the final stats dump. So, I grabbed my laptop and got started.
The Messy Start: Trying to Read the Tea Leaves
My first move? Always the same. I tried the manual way. I went to three different major sports portals and tried to copy-paste their live match center data. What a disaster. The HTML structure on those sites is always a nightmare. You get five layers of nested divs for one little timestamp. I spent thirty minutes just trying to isolate the time markers from the player names. Every site formats goals, yellow cards, and substitutions differently. One uses little icons, another uses acronyms. It was a massive headache trying to clean it up manually. I scraped the first page and ended up with a file full of garbage like <span class="event_card_yellow">YC</span>PlayerName (72’). Useless for fast facts.
I realized quickly I wasn’t just going to read the timeline; I had to build it myself from something less pretty but more structured. That meant going behind the curtain.
Digging Deep: My Shortcut to Clean Data
I threw out the manual scraping idea. Too much effort for a $50 bet. I decided to pivot and find the raw data feed the sites were using. Most of these sites don’t actually generate the data; they pull it from a centralized stats provider via some hidden JSON endpoint or API call. It’s usually tucked away in the page source if you know where to look. I fired up the developer tools on my browser and filtered the network traffic specifically for XHR requests.
It took maybe ten minutes of clicking around the match center page, expanding and collapsing elements, until BAM! There it was. A request for a large, ugly JSON file named something ridiculous like match_events_987654321_*. It was exactly what I needed. Everything was neatly time-stamped, categorized by event type (1=Goal, 2=Sub, 3=Yellow Card, etc.), and linked to the specific player ID.
I didn’t bother trying to reverse-engineer the actual API key. I just copied that request, pasted it into a little Python script—just maybe forty lines of ugly, quick-and-dirty code, nothing fancy—and told it to download that JSON straight to my machine. I wrote the script to do three things:
- Grab the File: Fetch the raw event data.
- Filter the Noise: Ignore things like throw-ins, fouls that didn’t result in cards, and corner kicks. I only wanted Goals, Cards, and Major Substitutions.
- Format Simply: Convert the Player ID and Event Type back into human-readable text and pair it with the minute marker.
The Revelation: The Simple, Clean Output
When the script finally ran, the result was instant and beautiful. It was just a clean list. No fancy graphics, no commentary, just the facts. The whole process, once I stopped messing around with the HTML, took under an hour.
Here is basically what the system spat out for the crucial parts of that game. I kept the teams separated because the initial file was just one long chronological log:
Birmingham City F.C. Timeline Events:
- 24’ MIN: Goal (Hogan, S.)
- 38’ MIN: Yellow Card (Bela, J.)
- 62’ MIN: Substitution (Leko for Bela, J.)
- 77’ MIN: Goal (Jutkiewicz, L.)
- 85’ MIN: Yellow Card (Gardner, G.)
Peterborough United F.C. Timeline Events:
- 48’ MIN: Goal (Taylor, S.)
- 55’ MIN: Substitution (Szmodics for Marriott, J.)
- 71’ MIN: Yellow Card (Ward, F.)
- 81’ MIN: Substitution (Mumba for Poku, K.)
The Conclusion and the Aftermath
I immediately highlighted the 62nd minute substitution for Birmingham City. That was the event Gary was claiming happened closer to 70. Wait, no. I checked the other important substitution. The one I was arguing about happened right before the 77th-minute goal. I looked closer at the raw feed and realized the change that truly mattered was the tactical switch at 75’. The system I built had simplified the official substitution at 62’, but the real change came later, and the raw data had two unlisted player movements that happened during a stoppage in play that weren’t recorded as ‘official’ subs but were crucial.
The core lesson here isn’t just about Python or JSON. It’s that raw data, even when seemingly clean, requires context. My script gave me the official timeline, but the real-world sequence was slightly different. Gary was still wrong about the 70th minute, but he wasn’t wrong about the feeling of the timing.
I showed him the timeline, proved he was wrong about the 70th minute, and won the $50. But the time I spent arguing and coding probably cost me way more than fifty bucks. Still, I got a great little script out of it that I still use today whenever someone tries to pull a fast one on me about sports history. Now I just run it, and within seconds, I have the unimpeachable truth. Simple, fast, factual.