Posts in api

If you've been following some of my recent work, you might've caught my latest blog post on enabling hidden game modes and maps in Halo Infinite. Well, clearly my curiosity got the best of me, because this post is very much a continuation of that story.

You might've seen over the course of the past couple of months since the Halo Infinite release some news and rumors about upcoming game modes in the game. I wondered how those folks got their hands on the new experience and just assumed that it's typical data mining in game files to look for new assets. That was until I really got hooked on the Halo Infinite story, started exploring the undocumented Halo Infinite API, and realized that the answer to my question was here all along!

If you've been following me on Twitter, you probably already know that I spend inordinate amounts of time on reverse engineering the Halo Infinite API. As I am working on my .NET wrapper for it (astutely called Grunt, I realized that putting together a nice-to-use blanket over the many GET HTTP APIs is relatively straightforward. There are some permissions here and there that I need to figure out, or in some cases fiddle with undocumented query parameters.

Now that I got authentication out of the way, it's time that we actually get something useful done with the Halo Infinite API. This whole saga started with me wanting to get the match stats so that I can analyze them outside the game, and that's what I thought I'd tackle first.

A week ago I was finally able to figure out what endpoints the Halo Infinite Web API uses. Now, the challenge became figuring out how to properly request the data from those, as there were two component pieces to every request - a Spartan token, and a clearance. After fiddling with the API a bit, and looking at the endpoint that aggregates all other endpoints, I was able to learn that there is a straightforward way to get all the right tokens through a number of chained requests, that are documented in this blog post.

As with most of my reverse engineering stories, this one starts with "Hmm... I wonder if I can get this data anyway?" I mentioned this in my previous blog post that I just finished the Halo Infinite campaign, and the next step was multiplayer, which also meant that I wanted to keep track of my stats to see just how bad I am playing against real people and aimbots.

I recently moved most of my websites over to Netlify, because, well - I work there, and I want to be dogfooding as much of our product as possible. As part of this, I enabled my sites to use Netlify Analytics, which has been a fantastic lens to look at the site usage from a server-side perspective.

Spotify's foray into podcasting may be fairly recent, but I'm already discovering some interesting APIs that I can play with. The podcaster dashboard is tremendously useful and offers way more data than Apple and Google combined (with better reliability too), so the more I use it, the more I started thinking that it would be helpful for me to build some kind of automation mechanism to ingest the data into my own storage and then process it outside the default dashboard boundaries. In the process, I also spotted a little thing that I wanted to share with readers, and that is the ability to enable experimental features inside your podcast private view.

Recently my Xbox started yelling at me every time I started taking a new game capture, reminding me that the storage for my account is full on the Xbox Live network. When I first got it, I thought that it had something to do with the fact that I am blocking outbound telemetry requests through PiHole, and all of a sudden, my local cache filled up.

Every year (unless you're one of those Apple Music people) music fans rejoice to get their Spotify Wrapped, or - the musical year in review. It's a fun way to explore the most frequently listened to songs and artists. And every year up until this one, if memory serves me right, the experience could be viewed in the browser. And then, I paid the site a visit in the year 2021.

The other day, Clint Rutkas (yes, that Clint Rutkas) tweeted about a potential scenario that GitHub does not have built-in, but that could be useful for folks that want to have a deeper look at the performance of their repositories - identifying "center of gravity" issues. What that means is essentially finding issues that are cross-referenced the most from other issues.

What's the most painful part of building anything with APIs? According to a tweet question I asked recently, one of the common themes was "authentication." Surprise, surprise - we're making that experience a bit easier with Netlify API Authentication by completely removing the step of handling the OAuth process "by hand."

I got into the habit of signing my GitHub commits. It’s awesome - anyone that looks at my repositories is able to tell that it really came from my account (and not someone just using my email). As an added bonus, I get a fancy badge associated with my commits, which makes me feel special (since I am not really “verified” anywhere else).

If you are a podcast owner, one of the things that can be a bit annoying is the multitude of different data points that are available for the show. Now, this is not the fact that there is too much data but rather that this data is scattered across different providers, with different systems, and different ways to manage it.

As I was getting ready to register myself, I quickly learned that all of the appointments that were available near me were all the way in June, which is still some time out. Not terribly bad, but I was wondering if I can get my first shot sooner. I've heard about folks who were cancelling their existing appointments and therefore making their previous time slots available, but I had no visibility into the process on the vaccination registration site.

2021 turns out to be a good year for folks like myself, that love collecting their own personal metrics. Earlier, I chatted about collecting air quality data, Twitter data - and now, GitHub contribution data. In this post I will describe a simple approach to grabbing your own GitHub contribution statistics without having to jump through too many hoops.

I just recently got a Stream Deck - it's a wonderful tool to automate some of the more boring (read: routine) tasks. Literally with a click of a button I can kick off a bunch of automation. Apparently it can do everything _but_ launch Windows Store applications.

I had a chat with a friend the other day, and he mentioned off-hand that in his life there is a very unique problem - lack of a short username for their Twitter account. Seems like everything good is already taken, which makes sense considering that Twitter itself is 14 years old. You can bet that in 14 years, a lot of people did get very creative with usernames.

Way back in 2018, I coded up a little project that allowed me to record my Nest camera stream in a _very_ hacky way. I wanted to get the raw video off of the camera without paying for a Nest Aware subscription.

I am naturally curious about the APIs that the devices in my house use, so when I got an air quality monitor, one of the first things I did was fiddle with the REST APIs that were made available through the device.

I recently moved all my development boxes to Windows. That’s right, all those Mac machines, with the exception of one that I need for testing, have been Boot Camp-ed to use the latest and greatest of the Windows 10 ecosystem. As part of this process, I started building some automation scripts - I’ve had that for macOS in the form of shell scripts that I could run whenever I re-installed the system, but nothing like that for Windows.

TL;DR: Check the source code out on GitHub for the project. It’s a demonstration of how you can use simple components to build awesome tools. That’s right, you don’t need Kubernetes for this! Table of contents Introduction The basics Ingress Data store Rendering layer Building the tools SQLite database Ingress script Analysis notebook Conclusion Introduction I’m one of those people that needs data around the things that I do - there is just something fun about being able to quantify and analyze things.

When building tools that authenticate against other APIs, more often than not I need to manage private keys and secrets. The challenge is that sometimes it’s very easy to forget the fact that the key is sitting somewhere in a configuration file, and it will be accidentally checked in to the repository. With the proliferation of tools like trufflehog, that’s generally not a position you want to be in. A lot of services are being proactive about it, and when a leaked key is detected, it will be automatically revoked (notice how it someone attempted to use it within minutes of the leak).

Whenever we talk about documentation infrastructure, one of the most common pieces of feedback I hear from developers is that it’s too complicated to set up. There is just too much configuration, fiddling around and trying to make sure that the output is produced in way that is expected. That’s why back in June I set out to build a documentation CLI that allows one to produce docs with one liners.

API documentation - something that often remains an after-thought for developers purely because writing it can be cumbersome, it requires working with a bunch of different tools (often very old), and maintaining it makes developers cringe just because that means they have to come up with good examples and descriptions, and let's face it - most developers would rather focus on writing code.

Summer is here, the city finally feels like you can take pictures of it from above without being “head in the clouds”, and that also means that it’s time to document how we generate .NET documentation on docs.microsoft.com. A while ago I wrote a post about documenting NuGet packages, and while it was a generally good description of high-level tools, it also missed the key detail - how to use DocFX to render the docs.

For one of the hobby projects, that I am working on, I thought I would leverage the Instagram API. It deals with an automation scenario, so the choice was obvious - I can put together a Python script that runs at scheduled intervals. Lucky for me, I’ve also learned that there is already a Python library that can help me access the API - it is archived and no longer maintained, but should at least give me some leverage over what I wanted to do.

I love looking at my Ubnt graphs - how much traffic goes where, to what clients, and many other interesting indicators. But I am also the kind of person that loves having raw access to the data, so I started digging - how can I pull those statistics locally? The setup I run is described here - I have a cloud key that manages the network, composed of a router acting as a switch, access point and the security gateway.

The holidays are right around the corner, and what better present is there for yourself, your loved one or your best friend than a limited edition laptop sticker that shows you support efforts to make technical documentation AWESOME? Lucky you, our dear user, because you can now get an absolutely free laptop sticker that showcases the .NET API Browser and the PowerShell Module Browser. Background Photo Source: StockIO.com. So what do you have to do to get the coveted stickers?

Last week I thought I would sit down and learn how to write a Visual Studio Code extension - what better way is there to test the documentation your company ships and give yourself the best holiday present of the year? I will start this by saying right away how easy it is to work on the extension across two platforms - part of it was written on a Windows machine, and another part of a mac.

I am a big fan of doing a lot of the monotonous automation work through Continuous Integration (CI). Specifically, I work a lot with defining workflows for documenting managed (.NET-based) API reference documentation. In the process, we leverage several tools, as you can read from one of my previous posts. The reality of software is, however, that it changes. New updates are pushed, new NuGet packages are released, and with that, there is a very high probability that the documentation changed as well.

In a race to optimize everything, developers often go to extremes to build software that performs routine tasks. MissionControl is a system that allows users to program a control center that stores interfaces with attached hardware sensors, allowing the users to control any other devices that can be activated via the underlying protocol.

With the release of Windows Phone 8, a few new developer API endpoints were made available that allow third-party applications to change the device lockscreen image. In this article, I am establishing the infrastructure and building a mobile application that provides the ability to choose from a number of dynamic image sets, from which images can be selected and then cycled as lockscreen wallpapers.

As I discussed the basic of authentication in my previous post, the most important Last.fm feature that is added to Beem in itself is track scrobbling, which will allow you to keep records of what you listened to from your favorite music aggregation service.

While working on Beem, I always relied on a static XML file to fetch me the list of available online radio streams. It’s a good way to keep the content dynamic, and when new stations are added, I do not have to re-submit the application for certification but rather just update the XML file.

Serialization is a process that is prone to errors, especially with a poorly structured data layer. However, that is not always the case and a seemingly normal serialization/deserialization scenario might turn out to produce unexepected results.

As Windows 8 adoption is growing (as a matter of fact, in the first month there were more than 40 million licenses sold), so is the number of Windows Store applications. I use some of the Windows Store delivered applications, such as Music, Netflix, Bing Weather and Bing Search quite often, but I also spend a lot of time in Visual Studio, which means that I am not in the Windows 8 shell, but I have access to the taskbar.

Multiple applications that are already in the Windows Phone Marketplace operate with a variety of content, such as pictures, text files and music. More often than not, that content is stored locally, in the application isolated storage, and although it is a good way to preserve that content, this method is bound to create some inconveniences in case the user decides to switch phones or do a complete device reset.

With the release of the new Windows Phone 8 SDK, the developers are now able to create URI associations, where their application can be launched from the context of another application.

For some situations, the controls that are out there are not enough. That is why I started working on my own control toolkit. As I work on my own applications and feel the need to implement a custom control, I will add it to the Windows Phone Control Kit collection.

A while ago we saw a demo from Microsoft that showed how it is possible to use Windows Phone to interact with a Kinect-powered game. During the Kinect Code Camp, right before the official release of the Kinect for Windows SDK beta, Adam Kinney, Rick Barazza, and I decided to work on a proof-of-concept project that would provide the same platform integration in a non-commercial development environment.

The official Kinect SDK is here, so there shouldn’t be any problems with incompatible frameworks and libraries on Windows systems. That being said, there are already a couple of interesting resources that I would say are important for developers who just start Kinect development, and for those that were already working with it (e.g. with OpenNI or OpenKinect).

I found out that the Xbox Live Game Marketplace content is syndicated via a web service tied to the Xbox Live CDN. The service returns enough information to build my own syndication client, which will be able to read game data about various titles that are currently available to be downloaded through the Xbox Live Marketplace. Here, I will explain some details on how exactly the queries can be built.

Have you ever wondered if the default YouTube application can be replaced? With tight system integration to the level where it has its own URI scheme registered, it seems like it’s a sealed deal and developers can’t do anything about it. What developers don’t know is that it is possible to fully replace the default YouTube application as long as you take it’s identity. Apparently Windows Phone OS recognizes applications by IDs only.

Windows Phone 7 comes with built-in support for YouTube. The system has a dedicated URI scheme registered for it, and I talked about it a while ago. It is pretty cool if the developer knows the URI scheme so that the application can be initiated from inside another application, but it is even cooler to disassemble the default YouTube application itself and attempt to integrate Microsoft-built capabilities in your own application.

I recently started working with the Netduino microcontroller and one of the initial projects I decided to tackle was creating a better sample for a LED matrix shield. It wasn’t really complicated – overall, it took me around an hour to put everything together and test it on a real device. Image lost since transition to new blog Here are some things that I added to the updated sample: Automatically initialize the I2CDevice instance when the LEDMatrix class is instantiated.

By default the Windows Phone emulator is pretty limited in terms of applications that are available out-of-the-box. In fact, Internet Explorer is the only application that is available – the rest are apps that are side-loaded. I already talked about a way to invoke the default YouTube application and about some other hidden call-related features. Today I found an interesting new access point that allows me to work with the Maps application without actually having the app accessible in the main menu.

I use Zune a lot, having started with the 4GB player, and now it’s available on Windows Phone 7. Though the WP7 player is labeled as Music Hub, it appears under the Zune icon and incorporates Zune’s organization, providing many of the same capabilities as the desktop client.

Facebook has a very useful API, that can give the developer access to pretty much anything Facebook-related when it comes to user profiles. The documentation provided comes in handy and it shows how to use the API from a web developer’s perspective – mostly giving examples in PHP. What if the developer wants to work with managed code in a desktop application? Since I am working with C#, I tried to implement some of the API calls in this language.

Snippet Manager is an application built by Danny Battison. Its main purpose is to help developers organize their code snippets in the cloud (those aren't stored locally). One of the interesting features of the application is that it offers an interface for plug-ins, although with a specific code structure.

For my latest project, WeatherBar, I had to pick a weather API. Basically, I needed to get the weather conditions for a specific location, as well as a short forecast. The choices I had were Yahoo Weather API, WeatherBug API and Google Weather API (yes,there is no mistake here – it is a direct API call, since Google doesn’t have an official page for this API). Probably there are more services offering a public weather API out there, but these caught my attention.