Ammar Sabilarrohman
For decades, the term "compatible" has functioned as a linguistic chameleon in the software industry. From the ubiquitous S3 object storage interface to the rapidly evolving OpenAI API, the most influential API contracts in the world were never formally ratified by standards bodies. Instead, they became industry standards through the raw force of replication. Developers copied successful patterns, vendors adopted them to ensure interoperability, and "compatible" became a marketing buzzword—a hollow promise often lacking any verifiable documentation or contractual weight.
This era of ambiguity may be coming to an end. A new "Standards" section launched on APIs.io aims to transition the industry from a culture of vague claims to one of verifiable measurement. By categorizing and grading API implementations based on actual, observable data, the project is finally answering the question: what does it actually mean to be compatible?
The Anatomy of the New Standard
The project centers on six initial "profiles" that measure industry-built APIs against the claims made by their adopters. Unlike traditional standards, which often exist as static, theoretical documents, these profiles are generated from the ground up, operation by operation.
The methodology relies on an "honest denominator": establishing what can be empirically verified. Compatibility claims are treated as mere assertions until they are validated by concrete evidence—whether that be a machine-readable OpenAPI specification, a successful live probe, or a formal declaration of support.
The Six Initial Profiles
| Profile | Claimed Adopters | Core Tier Operations | The "Compatibility" Reality |
|---|---|---|---|
| OpenAI Interface | 175 | 2 | Only Chat/Model list are universal. |
| Anthropic Messages | 20 | 2 | Heavily vendor-dependent. |
| Ethereum JSON-RPC | 40 | 22 | Highly consistent across nodes. |
| CKAN Action API | 48 | 63 | Driven by software release versions. |
| S3 Interface | 46 | 8 | A signal, not a census. |
| SCIM 2.0 | 320 | 5 | Massive gap between RFC and practice. |
A Chronology of "De Facto" Governance
The history of API standardization is a history of omission. For years, massive technology corporations—AWS, Microsoft, and OpenAI—have released and updated APIs that become the bedrock of the internet economy without the oversight of bodies like the IETF or W3C.
- The Early Days (2006–2015): The S3 interface emerged as the gold standard for object storage. It was copied widely, but without a formal, rigid specification, implementations drifted, creating a landscape of "mostly compatible" systems.
- The Formalization Attempt (2015): SCIM 2.0 was published as an RFC, providing a blueprint for user management. It became the gold standard for enterprise identity but, as data now shows, it is honored more in the breach than in the observance.
- The AI Gold Rush (2022–Present): The rise of Large Language Models (LLMs) saw the OpenAI API become the lingua franca of AI agents. Developers and startups rushed to claim "OpenAI-compatible" status, creating a massive fragmentation of features under a single label.
- The APIs.io Pivot (2026): APIs.io shifts the focus from "governance by committee" to "governance by artifact," releasing tools that allow any provider to test their compliance against the actual, measured behavior of the industry.
Supporting Data: The "Core Tier" Philosophy
One of the most innovative aspects of the APIs.io approach is the concept of the "Core Tier." By grading per method and path—recognizing that a GET request and a POST request to the same endpoint may have vastly different implementation rates—the project creates a realistic floor for compatibility.
The Case of the OpenAI Interface
The data is particularly revealing regarding the OpenAI API. Out of 338 graded operations, only two—chat completions and the model list—reach the "core" tier. The remaining 317 operations are categorized as "vendor-only." This suggests that "OpenAI-compatible" is a misleading label if used to imply a comprehensive feature set. It is a baseline, nothing more.
The SCIM Paradox
SCIM 2.0 provides a cautionary tale about the limits of formal ratification. Despite being an RFC since 2015, the actual implementation data shows a staggering gap. While 368 providers claim SCIM compatibility, the vast majority do so in prose without publishing a machine-readable spec. Only five core operations (CRUD on /Users) are consistently implemented. Everything else—groups, bulk filtering, schemas—is fragmented across the ecosystem.
Official Responses and Industry Implications
The project’s architects argue that these profiles are not merely reports; they are "artifact sets." Every profile generates an OpenAPI spec, a conformance test (Arazzo workflow), and a Spectral ruleset.
For the enterprise, the implications are profound. If a company claims compatibility with a standard, they are now only one "linting" process away from having their claim verified or debunked. The industry is effectively being given a mirror to look at its own technical debt.
Industry analysts have noted that this move towards "Artifact-as-Standard" aligns with the growing importance of the "Kin Score," which rewards regulatory posture and contract governance. By shifting the conversation from "Do you claim this?" to "Can you demonstrate this?", the industry is moving toward a more mature, reliable infrastructure.
The Gap Between Identity and Utility
Perhaps the most telling data point in the entire report is the list of standards that nobody carries. While nearly 400 providers tag themselves as supporting GraphQL, cutting-edge specifications like the Model Context Protocol (MCP) show zero provider tags, despite being indexed in thousands of server records.
This highlights a fundamental tension: standards are often treated as marketing assets rather than technical realities. Companies are happy to claim a "popular" standard to signal alignment, but they are hesitant to commit to emerging standards until they become necessary for survival.
Conclusion: The Path Forward
The APIs.io standards initiative is a clarion call for honesty in software engineering. By treating compatibility as a measurable, verifiable fact rather than a marketing claim, the project provides a blueprint for a more stable, interoperable digital ecosystem.
If your company claims compatibility with S3, SCIM, or the OpenAI interface, the time for "prose-based compliance" is ending. The registries are now open, the rulesets are published, and the evidence is available for all to see. In the modern era of API-first development, the most powerful standard is not the one you claim to follow, but the one you can prove you actually run.
For developers, this means fewer hours spent debugging "compatible" endpoints that don’t quite behave as advertised. For providers, it means a clear, tiered roadmap to true interoperability. The era of the "de facto" standard is evolving into the era of the "verifiable" standard, and the industry is arguably better for it.
Reynand Wu
Azzam Bilal Chamdy
