When people hear this definition, they usually think of web scrapers, which are notoriously unreliable and obnoxious to maintain.

Unlike a web scraper, an Unofficial API is an interface built for continuous, bidirectional interaction. This has two important implications:

1. Unofficial APIs are optimized for executing atomic events, such as updating information about a single customer or fetching structured data from a new business found in a registrar.

2. Unofficial APIs require a ‘contract’ to be considered usable. There must be a clear maintainer and documented expectations for performance & change management. In other words, people must be able to trust that they can integrate the API into a workflow and use it reliably.

This can seem like a high bar, but it’s necessary to give Unofficial APIs credibility.

Infrastructure is never ready for major changes

Plaid started in 2013, when digital banking was becoming mainstream. Consumers wanted to manage their money online, but banking infrastructure was stuck in the 80s.

If Plaid waited for banks to catch up, they would’ve run out of cash. Instead, they built the infrastructure themselves to integrate with financial institutions, and proved to the industry that it needed better integrations.

It’s a tale as old as time — innovations drive the need for new infrastructure. The AI revolution is no different. Agents are really good at analyzing unstructured information and orchestrating a set of tasks. They perform best when they have a well-defined set of tools or functions that they can use.

The problem is that the number of use cases for agents is infinite, but APIs are not. This gap is widening as industries running on specialized vertical software demand AI-powered efficiency gains, but these core systems lack any APIs.

Once again, it’s impractical to wait for the infrastructure to catch up. Developers need to be able to integrate with any arbitrary website or app in a consistent, reliable way.

The time has come for Unofficial APIs to be mainstream

The key blocker to large scale adoption of Unofficial APIs has always been maintenance. Each integration has been bespoke code that only the original developer understands. When new features are added to an app or page layout changes, it can break the integration without warning and wake up the only developer who understands the code and the underlying system.

The game-changer? LLMs can solve the maintenance problem. They can quickly process unstructured documentation, make small tweaks to code and can identify root causes when paired with instrumentation. Best of all, when trained on tons of integration examples, work well at adapting to interface changes.

Browser automation tools try to solve the problem by creating an entirely new type of interface. They make for a slick demo and give the impression of being able to automate anything, but suffer from reliability and performance issues that make them impossible to use right now for any large scale application.

Why add an entirely new type of unpredictable interface to your stack, when developers actually want deterministic and reliable APIs?

Deliver what engineers need - consistent interfaces that work at scale, not flashy demos that will inevitably break in production.

Unofficial APIs in action in PropTech

Tons of PropTech companies rely on Zillow in some way to run their business. The problem? The most commonly used products, such as rental and listing management, sits behind a login with no API. This makes it complicated & expensive to integrate Zillow into an automated process.

The good news is that most PropTech companies have well-defined manual processes built around Zillow. This is where Unofficial APIs shine. Instead of brittle scraping or clunky browser automation, an Unofficial API provides:

1. A clean, RESTful interface to Zillow's data that feels just like an official API

2. Secure credential management handling both login and MFA

3. Predictable response formats that normalize Zillow's complex UI into structured data

4. Resilience against Zillow's frequent UI changes

For developers, the integration becomes a simple set of API calls that fit their existing workflow, not a complex automation system requiring constant babysitting. They can fetch property data on demand, run analytics, and report back to their customers without worrying about the underlying connection to Zillow breaking.

We’re seeing this same pattern play out in other industries like LegalTech, GovTech, InsureTech and Healthcare, where a lack of APIs are holding them back from innovating at pace.

The future of integrations is unofficial (but managed) APIs

Integrating with applications that already have clean, official APIs is easy. The real competitive advantage and value will come from augmenting those integrations with the long tail of systems that don't have great APIs—or any APIs at all.

But to be successful, these Unofficial APIs must be:

• Managed with rigorous monitoring, testing, and maintenance protocols

• Purpose-built to provide the exact functionality required by developers and reduce the need to manage complex schema mapping logic.

• Reliable with SLAs that match or exceed those of official APIs

Developers that augment their existing API stack with unofficial ones will see the most benefits from AI and advanced automation. They'll integrate with systems previously considered impossible or too flaky to depend on programmatically.

Instead of waiting for infrastructure to catch up to AI, these developers will show the industry what’s possible.

Many folks in the industry, technical and non-technical alike, do not realize that LLMs are pretty bad at calling APIs — at least without some serious coaxing via prompts or bespoke code.

APIs are the foundation for building and connecting software, so its surprsing that LLMs are unable to utilize such standard technology out of the box.

How does MCP work today?

The current implementation of MCP is typically deployed as an “MCP Server” that runs locally on the same machine where you’re accessing your models.

So, if you utilize a program like Claude Desktop or Cursor on your Mac, the MCP server will run behind the scenes, locally, on your Mac.

This server provides the LLM with basic information such as:

1. Which APIs are available to use?

2. How should I think about when to use these APIs?

3. How do I actually call these APIs?

4. What data would I get back if I were to make an API call?

If you’ve written any significant amount of code in the last decade, you’d quickly realize that this setup of needing a local server to a call a remote server (or an API for your APIs) is really weird.

Why is the current version of MCP so weird?

This section is not intended to dunk on the fine engineers at Anthropic who came out with MCP. They built MCP to solve a real problem and there are real constraints in dealing with LLMs to enact a solution.

LLMs are unbelievably good at following patterns in language, be it human or a programming language.

LLMs aren’t great at being asked a very human question and then being expected to switch to behaving like a computer for a brief moment mid-sentence, and then finish the conversation as a human. They can sort of do this, but its very unreliable.

In order to solve this problem, an LLM needs outside help. In most software, outside help usually comes in the form of calling an external API. But most LLMs don’t have the infrastructure needed to call APIs.

To solve this, you need an API to call APIs.

In order to give LLMs an API to call APIs, The Anthropic team came up with this clever solution of installing an MCP server that plugs in to wherever your models are being used to help translate this human-to-machine-back-to-human transition without requiring any fundamental changes to the model.

What’s next?

The future when any LLM is able to reliably call external APIs without much friction will be an enormous unlock for every industry. While not perfect, and a little weird, MCP is currently the best first step in that direction.

We built Supergood for this inevitable future — the demand for LLMs needing to access a product’s APIs will exceed the supply of APIs available for use.

Supergood generates and actively maintains APIs for products that do not have APIs. We utilize a combination of human-in-the-loop code generation paired with our in-house observability platform to quickly create new integrations and free up your engineering team from ongoing maintenance.

If you want to learn more, schedule some time with me!

We’re also hiring Engineers and Generalists in San Francisco.

Ask it to find menu prices from Chicago restaurants and you'll get a wall of text about Lou Malnati's famous deep dish instead of a clean table of restaurants, prices, and items.

We've been working with Claude to tackle this problem, and we've found that by combining Anthropic's Model Context Protocol (MCP) with real-time structured web data powered by Supergood integrations, we can dramatically improve the accuracy and usefulness of LLM’s.

LLM + Web Data: Great for demos, not for scale

Let's look at an example: trying to find pets available for adoption. Using a tool like Perplexity, which lets LLMs search the internet, you might ask "What pets are available for adoption in Burlington, NC? Show the results as a table."

The tool retrieves unstructured data gathered from various parts of the internet and jams it into a table. At first glance, this seems acceptable for a consumer performing cursory research.

But upon closer inspection, these results are sparse, inaccurate, and generally impossible to build a quality product around. In reality, there are actually dozens of dogs and rabbits (and one pig named Perry) available for adoption in Burlington that Perplexity doesn’t seem to be aware of.

If you’re part of a product, engineering or data & analytics team building for scale, and you’re looking to use AI to help you integrate or analyze web data into your product, your $20 subscription to your favorite LLM won’t cut it.

Solving the scale problem requires better tools

When we use Anthropic's Model Context Protocol (MCP) and provide Claude with a tool generated with Supergood, the difference is striking:

We’ve overcome two key limitations of off-the-shelf LLMs:

• We have full control over the sources LLMs can use, forcing the model to prioritize high-quality structured datasets that off-the-shelf LLMs will not have available.

• We can enable LLMs to search across entire, massive datasets, rather than cramming whatever unstructured data you can fit into a context window.

This is huge for common AI applications where access to sources of high quality, structured information, dramatically increases the accuracy of complex queries.

As an example, RAG applications require data to be chunked in a way that provides meaningful information about relationships and context, while staying within token limitations. When data is well-structured, you cut out a lot of the fluff that has a high token cost but doesn’t add (and sometimes even degrades) the quality of results.

This extends beyond RAG applications and is a hard truth about LLMs — they work way better when they have access to structured data.

MCP bridges the gap between models and tools

MCP is Anthropic's protocol for standardizing how models interact with external tools. Think of it as a universal adapter that lets models like Claude seamlessly connect with specialized tools while maintaining consistent output formats.

The protocol defines how tools describe their capabilities to the model and provides standard formats for data ingest & output. This standardization means that once a tool implements MCP, it can be used by any model that supports the protocol.

Long-term, this should lead to better interoperability across the AI ecosystem. Short-term, this lets us see drastic improvements to Claude output when equipped with better tools.

Structured, real-time web data: AI’s killer power tool

Perplexity and similar tools do a great job at what they're built for: giving humans quick answers from the web. But embedding web data for production-worthy AI applications requires a fundamentally different approach.

The challenge with web data isn't just extraction - it's maintaining a reliable data pipeline outputting consistently high-quality data that can handle the mess of modern web apps. The engineering maintenance cost associated keeping up with ever changing web makes it nearly impossible to maintain consistent data quality at scale.

This is where Supergood comes in. Supergood generates unofficial APIs that are officially maintained. The platform combines LLMs with our proprietary observability data and human-in-the-loop expertise to ensure high-quality, structured data, reliably delivered.

The result? Your AI-powered apps and workflows can use real-time web data from all of the sources that you need, without requiring you to dedicate your best engineers to build & maintain a bunch of flaky integrations and data sources.

See it for yourself

MCP is just getting started, but the potential for utilizing it with reliable web data is already clear. If you're experimenting with AI agents and tools, hit us up at hello@supergood.ai. We'd love to chat and see if real-time web data can take your product to the next level.

We’re hiring !

We’re looking for talented engineers and generalists to join our team in San Francisco. Check us out at https://supergood.ai/careers