A Comprehensive History of APIs

Introduction

The Application Programming Interface, or API, is one of the most foundational concepts in the history of software. It is the mechanism through which discrete pieces of software communicate, share data, and extend one another's capabilities. What began as a cataloging system for reusable code stored on punched paper tape has evolved into a global infrastructure layer that powers everything from mobile applications to financial markets to large language models. The story of the API is, in many respects, the story of modern computing itself.

This paper traces the complete lineage of the API from its conceptual origins in the 1940s through the present day, documenting the key figures, critical dates, technical milestones, and paradigm shifts that have defined its trajectory. The intent is to provide a factual, chronological account suitable for both technical and non-technical audiences, with sources cited throughout.

I. Conceptual Origins (1940s - 1950s)

The intellectual groundwork for APIs was laid before the term itself existed. In 1947, Herman Goldstine and John von Neumann published Planning and Coding of Problems for an Electronic Computing Instrument, Part II, Volume III, in which they argued that most programs would need to rely on common operations and that a shared library of subroutines would dramatically reduce both the volume of new code and the incidence of errors. This was among the first formal articulations of what would eventually become the API concept: a defined, reusable interface through which software could invoke pre-built functionality (Nordic APIs, 2018).

In 1949, British computer scientists Maurice Wilkes and David Wheeler brought this idea to life with the Electronic Delay Storage Automatic Calculator, or EDSAC, at the University of Cambridge. They developed a modular software library whose subroutines were stored on punched paper tape and organized in a physical filing cabinet. Alongside the tapes, the cabinet contained a "library catalog" of notes explaining how to incorporate each subroutine into a program. Wilkes and Wheeler published the details of this system in their 1951 book, The Preparation of Programs for an Electronic Digital Computer. By modern standards, that catalog functioned as an API specification: it instructed programmers on how to call each available subroutine (Wikipedia, "API," 2026).

Also in the 1950s, IBM developed Fortran, the first widely adopted high-level programming language, released in 1957. Fortran's CALL statement, refined in Fortran II around 1958, allowed a main program to invoke independent code blocks for tasks such as mathematical computations. This provided a template for procedure-oriented interfaces that promoted code reuse and separation of concerns, both of which are central to how APIs function today (Grokipedia, "API," 2025).

II. The Term Emerges (1960s)

The 1960s brought both the growing complexity of computer systems and the formal coining of the term "API." In 1964, IBM introduced the System/360, a family of mainframe computers that represented a major step toward standardized programming interfaces. IBM provided programmers with documentation and libraries that enabled access to core system functions, establishing patterns that would later define commercial API design (Devzery, 2025).

The term "Application Programming Interface" itself first appeared in print in 1968, in a paper titled Data Structures and Techniques for Remote Computer Graphics by Ira W. Cotton and Frank S. Greatorex, presented at the AFIPS Fall Joint Computer Conference. The authors used the term to describe the interaction between an application (a graphics program) and the rest of the computer system. Their interface, built on Fortran subroutine calls, was designed to free programmers from dealing with the idiosyncrasies of specific graphics display devices and to ensure hardware independence (Wikipedia, "API," 2026; letscountapi.com, 2025).

Douglas Engelbart, best known for inventing the computer mouse, also contributed to the conceptual lineage during this period. His pioneering work in human-computer interaction in the 1960s laid the groundwork for systems that could communicate through shared protocols, foreshadowing the interoperability that APIs would eventually provide (Devzery, 2025).

III. Standardization and Networks (1970s - 1980s)

In 1974, C. J. Date published a paper titled The Relational and Network Approaches: Comparison of the Application Programming Interface, which introduced the term API to the field of databases. The API subsequently became a part of the ANSI/SPARC framework for database management systems, which treated the application programming interface as a distinct layer separate from query interfaces. Database professionals in the 1970s observed that these different interfaces could be combined and that a sufficiently rich application interface could support other interfaces as well (Wikipedia, "API," 2026).

The late 1960s and early 1970s also saw the rise of modular programming as a formal discipline, emphasizing the decomposition of complex systems into smaller, manageable modules. This approach directly influenced how APIs would eventually be designed: as bounded, well-documented contracts between software components (Qodex.ai, 2024).

As computer networks became more common in the 1970s and 1980s, programmers increasingly needed to call libraries located on remote computers, not just their local machines. This need gave rise to Remote Procedure Calls, or RPCs. In 1984, Sun Microsystems introduced its RPC system, which was widely adopted and became part of the Unix operating system. RPC allowed programs to execute procedures on other computers as if those procedures were local, a significant step toward distributed computing and the foundation for later network-based APIs (Qodex.ai, 2024).

Unix itself, developed at Bell Labs in the 1970s and gaining broad adoption in the 1980s, introduced a set of system calls that functioned as APIs for tasks such as file manipulation, process control, and inter-process communication. These system calls established many of the conventions that operating system APIs would follow for decades (letscountapi.com, 2025).

IV. The Web and Protocol Wars (1990s)

The 1990s were defined by two developments that would reshape APIs entirely: the invention of the World Wide Web and the emergence of competing protocols for web-based communication.

Tim Berners-Lee's creation of the World Wide Web in the early 1990s opened new channels for information exchange, and with it, new possibilities for programmatic communication between systems. Standards like CORBA (Common Object Request Broker Architecture), COM (Component Object Model), and DCOM (Distributed Component Object Model) competed throughout the decade to become the dominant way to expose API services over networks (Wikipedia, "API," 2026).

The W3C published XML as an official recommendation in February 1998, providing a machine-readable and human-readable markup language for structuring data. XML became the backbone for a new wave of web service protocols (The History of the Web, 2023).

That same year, SOAP (Simple Object Access Protocol) was conceived at Microsoft by Dave Winer, Don Box, Bob Atkinson, and Mohsen Al-Ghosein. Due to internal politics at Microsoft, Winer released a lightweight precursor called XML-RPC in June 1998 as part of Frontier 5.1. The full SOAP specification was submitted to the IETF on September 13, 1999, and version 1.1 was published as a W3C Note on May 8, 2000, after Microsoft and IBM collaborated to push the standard through (Wikipedia, "SOAP," 2025; The History of the Web, 2023).

SOAP standardized the communication between servers using XML-based messaging, providing a structured framework with rules for message formats, encoding, and error handling. It quickly became the dominant approach for enterprise web services, adopted by organizations including Oracle, HP, and Sun Microsystems (The History of the Web, 2023; Stoplight, n.d.).

V. The First Web APIs and the Birth of REST (2000 - 2004)

The year 2000 marked a turning point in API history. Three events occurred that would set the trajectory for the next two decades of software development.

Salesforce (February 7, 2000)

Salesforce officially launched its API at the IDG Demo conference on February 7, 2000. The company had been built from its inception around the concept of "Internet as a Service," and XML APIs were a fundamental part of its architecture from day one. The initial SOAP-based API was complex, with a PDF manual running to several hundred pages, but it was groundbreaking in that it allowed customers to share data across business applications programmatically. This made Salesforce a platform, not just a product, and set an industry pattern for how services could be leveraged and extended through APIs (Postman Blog, 2024; Nordic APIs, 2025).

Roy Fielding's Dissertation (2000)

Also in 2000, Roy Fielding completed his doctoral dissertation at the University of California, Irvine, titled Architectural Styles and the Design of Network-based Software Architectures. In it, he outlined Representational State Transfer, or REST, and described the concept of a "network-based Application Programming Interface" built on the existing protocols of the web. REST emphasized a uniform interface using standard HTTP methods (GET, POST, PUT, DELETE), stateless communication, and resource-based URLs. Fielding's work provided the theoretical foundation for an alternative to SOAP that was simpler, more scalable, and better aligned with how the web already worked (ReadMe, 2025; Wikipedia, "API," 2026).

eBay (November 20, 2000)

On November 20, 2000, eBay launched its Application Program Interface along with the eBay Developers Program. Initially rolled out to a select number of licensed partners, the eBay API allowed developers to pull product and auction data directly from the platform. Unlike Salesforce's SOAP-based approach, eBay offered a more developer-friendly REST API with thorough online documentation. The move demonstrated the commercial value of opening platform data to external developers and fundamentally expanded where and how goods could be sold online (Postman Blog, 2024; API Evangelist, n.d.).

Amazon Web Services (July 16, 2002)

On July 16, 2002, Amazon launched Amazon.com Web Services, allowing developers to incorporate Amazon content and features into their own websites. Developers could search and display products in XML format. Internally, Amazon adopted an API-first mandate, often attributed to CEO Jeff Bezos, requiring every team to expose its data and functionality through APIs. This internal discipline would later give rise to the cloud computing infrastructure that became Amazon Web Services as we know it today (Postman Blog, 2024; The History of the Web, 2023).

The Social API Wave (2003 - 2004)

In 2003, the bookmarking service Delicious (originally del.icio.us) launched an API that allowed users to retrieve their bookmarks in XML format simply by changing a URL extension. Flickr followed shortly after, providing an API for its image-hosting platform. These services demonstrated that APIs could power user-generated content platforms and that opening data to developers could accelerate platform adoption in ways that internal development alone could not (Postman Blog, 2024; The History of the Web, 2023).

VI. The Social and Cloud Era (2005 - 2010)

Google Maps API (2005)

Google Maps launched its public API in 2005, and it became one of the most consequential API releases in history. The API spawned a wave of "mashups," where developers combined Google's mapping data with other data sources to create entirely new applications. With over 2,000 mashups built on it, the Google Maps API demonstrated the immense value of geographic data delivered through a reusable interface. Lars Rasmussen, the original developer of Google Maps, noted how much the team learned from the developer community by watching how they adapted the application in real time (API Evangelist, n.d.).

Amazon S3 and EC2 (2006)

In 2006, Amazon launched two services that would redefine the technology industry. Amazon Simple Storage Service (S3) provided a basic, API-accessible storage service with a pay-as-you-go pricing model. Amazon Elastic Compute Cloud (EC2) followed, offering on-demand computing resources through the same API-driven approach. Together, these services established the model for cloud computing and proved that essential digital infrastructure could be delivered entirely through APIs. The shift was profound: computing resources became programmable, scalable, and accessible to any developer with an internet connection (Postman Blog, 2024; API Evangelist, n.d.).

Twitter API (September 20, 2006)

Twitter introduced its API on September 20, 2006, initially as a response to users who were already scraping the site and building unofficial integrations. The API exposed Twitter's data through a RESTful interface supporting both JSON and XML formats. Within four years, the Twitter API became the backbone of countless desktop clients, mobile applications, and web tools, and even powered Twitter's own official apps. The platform became a case study in how a well-designed API could drive an entire ecosystem of third-party innovation (API Evangelist, 2011).

Mashery and API Management (2006)

Also in 2006, Mashery launched as the first dedicated API management platform, offering standardized tools for API providers to manage deployment, access control, and analytics. This marked the beginning of API management as its own industry, laying the groundwork for companies like Apigee, MuleSoft, and Kong that would follow (API Evangelist, n.d.).

Twilio (November 20, 2008)

Twilio, founded in 2008 by Jeff Lawson, Evan Cooke, and John Wolthuis, launched Twilio Voice on November 20, 2008. The product was a RESTful API for making and receiving phone calls entirely through the cloud. Twilio's text messaging API followed in February 2010. The company pioneered the "API as a product" model, abstracting the complexities of telecommunications infrastructure into simple, developer-friendly interfaces with pay-as-you-go pricing. Twilio demonstrated that APIs could serve not just as data connectors but as entire product categories in their own right (Wikipedia, "Twilio," 2026).

Stripe (2011)

Stripe launched its payment processing API in 2011, founded by brothers Patrick and John Collison. The API allowed developers to accept payments with just a few lines of code, eliminating the complexity that had historically characterized payment integration. Stripe's developer-centric approach, including clean documentation, intuitive endpoint design, and a sandbox testing environment, became a template for how modern APIs should be designed and documented. Stripe helped establish the expectation that APIs should prioritize developer experience alongside functionality.

VII. Specification, Standardization, and New Paradigms (2010 - 2015)

Swagger / OpenAPI (2010 - 2016)

In 2010, SmartBear Software created Swagger, a specification format for defining and documenting RESTful APIs. Swagger provided a machine-readable way to describe API endpoints, parameters, data types, and authentication methods. In November 2015, SmartBear donated the Swagger specification to the newly formed OpenAPI Initiative, a collaborative project under the Linux Foundation. The founding members included Google, IBM, Microsoft, PayPal, and Capital One. The specification was renamed the OpenAPI Specification, and version 3.0 was released in 2017. It became the industry standard for REST API documentation and design, enabling code generation, interactive documentation, and contract testing across platforms (OpenAPI Initiative FAQ, n.d.; Tailcall, 2024).

GraphQL (2012 - 2015)

Facebook began developing GraphQL in 2012 to solve a specific problem with its mobile newsfeed. The existing REST API architecture required the client to make many separate requests to different endpoints to assemble all the data needed for a single view. On mobile networks with limited bandwidth, this was a significant performance bottleneck. GraphQL introduced a query language that allowed clients to specify exactly what data they needed in a single request, and the server would return precisely that data. Facebook open-sourced the GraphQL specification in 2015, and in 2018, governance was transferred to the GraphQL Foundation, hosted by the Linux Foundation. Major platforms including GitHub, Shopify, and Yelp subsequently adopted GraphQL for their public APIs (Wikipedia, "GraphQL," 2025; GraphQL.org, n.d.).

gRPC (2015 - 2016)

Google open-sourced gRPC in 2015 as a high-performance Remote Procedure Call framework. Built on HTTP/2 and Protocol Buffers (a binary serialization format), gRPC was designed for scenarios where performance and type safety were critical, such as microservice-to-microservice communication. Unlike REST, which uses human-readable JSON or XML, gRPC's binary format produced smaller message sizes and faster parsing times. The framework was released publicly in 2016 and has since been adopted by companies including Netflix, CockroachDB, and CoreOS for connecting distributed systems (Java Code Geeks, 2025; Koyeb, n.d.).

VIII. The API Economy (2010s)

By the early 2010s, the cumulative impact of the preceding decade's API development had produced a new economic reality. APIs were no longer just technical integration tools; they were strategic business assets. Companies began to recognize that their data and services, exposed through APIs, constituted a platform that could attract third-party developers, generate new revenue streams, and create network effects that strengthened the core business.

Salesforce's AppExchange, launched in 2005, had already demonstrated this by creating a marketplace for third-party applications built on Salesforce's API. By the 2010s, the exchange hosted thousands of applications driving billions of dollars in transactions. The model proved that an API could transform a product company into a platform company (Nordic APIs, 2025; Salesforce Ben, 2023).

The proliferation of mobile devices accelerated this shift. As smartphones became the primary computing platform for consumers, the need for APIs to power mobile applications grew exponentially. Every mobile app that displayed a map, processed a payment, sent a notification, or authenticated a user was relying on one or more APIs to do so. The "API economy" became a recognized category in technology strategy, with analysts estimating that APIs were intermediaries in a significant share of global digital commerce.

This period also saw the maturation of API management as a discipline. Companies like Apigee (acquired by Google in 2016), MuleSoft (acquired by Salesforce in 2018), and Kong emerged to provide tools for API gateway management, rate limiting, authentication, versioning, and analytics. The API lifecycle, from design to deployment to deprecation, became a formalized practice within enterprise software development.

IX. APIs and the Law: Oracle v. Google (2010 - 2021)

The legal status of APIs was tested in one of the most significant intellectual property cases in technology history. In 2010, Oracle filed a lawsuit against Google, alleging that Google's implementation of Java APIs in the Android operating system violated both patent and copyright protections. The case wound through the courts for over a decade.

In 2012, a jury found no patent infringement, and the presiding judge ruled that APIs could not be copyrighted. Oracle appealed, and in 2014, the U.S. Federal Circuit Court of Appeals reversed the lower court's ruling on copyright. Google petitioned the Supreme Court, which initially declined to hear the case. In 2016, a jury found Google's use of the Java APIs constituted fair use, but Oracle appealed again. In 2017, Stanford University and 76 scientists and engineers filed an amicus brief supporting the right to reimplement APIs. The case finally reached the Supreme Court, which ruled 6-2 in April 2021 that Google's use of the Java API declarations was fair use. The decision was widely viewed as a critical affirmation that API interoperability should be legally protected (Nordic APIs, 2018; U.S. Supreme Court, Google LLC v. Oracle America, Inc., 2021).

X. The AI Era: APIs as Intelligence Infrastructure (2020 - Present)

The most recent chapter in the history of APIs is being written in real time, driven by the rapid emergence of artificial intelligence as a commercial technology. APIs have become the primary delivery mechanism through which AI capabilities are distributed to developers and businesses worldwide.

OpenAI API (June 2020)

In June 2020, OpenAI announced GPT-3 alongside the OpenAI API, which became the company's first commercial product. The API allowed developers to access GPT-3's text generation capabilities through simple HTTP requests, making advanced language modeling available without requiring specialized hardware or machine learning expertise. The release of ChatGPT in November 2022, powered by GPT-3.5, catalyzed global interest in generative AI and drove rapid adoption of the API. OpenAI has since expanded the platform to support text generation, embeddings, image generation (DALL-E), text-to-speech, and vision capabilities (Popular Timelines, 2025; is4.ai, 2025).

Anthropic and the Claude API (2021 - Present)

Anthropic was founded in 2021 by former OpenAI researchers, including siblings Daniela and Dario Amodei. The company's flagship Claude models were first made available through an API in 2023, with Claude 2 launching publicly in July 2023. In March 2024, Anthropic released the Claude 3 family (Opus, Sonnet, and Haiku), and in May 2025, the company introduced Claude 4 with expanded API capabilities. Anthropic's approach to API design has emphasized safety, reliability, and predictable behavior, using a technique called Constitutional AI in which models are trained to adhere to a defined set of principles (Wikipedia, "Anthropic," 2026).

The Broader AI API Landscape

Google's Gemini API, Meta's LLaMA models, Cohere, Mistral, and numerous other providers have entered the market, each offering AI capabilities through API interfaces. The pattern is consistent: the API serves as the distribution layer that transforms a research breakthrough into a commercially usable service. Beyond large language models, AI APIs now power image generation, video synthesis, speech recognition, code completion, and autonomous agent frameworks.

A new class of API protocols has also emerged to support AI-native workflows. Anthropic's Model Context Protocol (MCP), for example, provides a standardized way for AI models to interact with external tools and data sources through structured API calls. These protocols represent the latest evolution in API design, extending the concept from system-to-system communication to model-to-world interaction.

The economic significance of AI APIs is substantial. OpenAI raised $40 billion at a $300 billion valuation in April 2025. As of February 2026, Anthropic has reached an estimated valuation of $380 billion. The scale of these figures reflects the centrality of APIs as the commercial interface through which AI capabilities are monetized and deployed (Wikipedia, "OpenAI," 2026; Wikipedia, "Anthropic," 2026).

Key Dates in API History

Conclusion

The history of the API is a story of progressive abstraction. Each era has moved the interface further from the physical hardware and closer to the conceptual domain of the developer. Punched paper tape became subroutine libraries. Subroutine libraries became system calls. System calls became remote procedure calls. Remote procedure calls became web services. Web services became REST APIs. REST APIs became the delivery mechanism for cloud infrastructure, mobile platforms, and now artificial intelligence.

At every stage, the pattern has been the same: a complex capability is packaged behind a well-defined interface, and that interface enables an ecosystem of innovation that the original creators could not have anticipated. The Google Maps API did not just serve map tiles; it enabled ride-sharing, real estate, and logistics companies that did not yet exist. The OpenAI API did not just generate text; it enabled a generation of AI-native applications across every industry.

What remains consistent across eight decades is the fundamental promise of the API: that software should be composable, that capabilities should be shareable, and that the boundary between systems should be defined clearly enough for others to build upon. That promise, first articulated in a filing cabinet at Cambridge in 1949, continues to define the architecture of the digital world.

Sources Cited

API Evangelist. "History of APIs." https://history.apievangelist.com/

API Evangelist. "History of APIs: Twitter." January 26, 2011. https://apievangelist.com/2011/01/26/history-of-apis-twitter/

API Evangelist. "History of APIs: Twilio." June 13, 2013. https://apievangelist.com/2013/06/13/history-of-apis-twilio/

Cotton, Ira W. and Frank S. Greatorex. "Data Structures and Techniques for Remote Computer Graphics." AFIPS Fall Joint Computer Conference Proceedings, 1968.

Date, C. J. "The Relational and Network Approaches: Comparison of the Application Programming Interface." 1974.

Devzery. "Who Invented API? A Complete Guide to Its Origins." January 22, 2025. https://www.devzery.com/post/who-invented-api

Fielding, Roy Thomas. Architectural Styles and the Design of Network-based Software Architectures. Doctoral Dissertation, University of California, Irvine, 2000.

Goldstine, Herman H. and John von Neumann. Planning and Coding of Problems for an Electronic Computing Instrument, Part II, Volume III. Institute for Advanced Study, Princeton, 1947.

GraphQL Foundation. https://graphql.org/

Grokipedia. "API." 2025. https://grokipedia.com/page/API

is4.ai. "OpenAI API vs Anthropic API: Complete Comparison 2025." December 30, 2025. https://is4.ai/blog/our-blog-1/openai-api-vs-anthropic-api-comparison-117

Java Code Geeks. "API Design in Java: REST, GraphQL, gRPC Comparison." December 20, 2025. https://www.javacodegeeks.com/2025/12/api-design-in-java-rest-graphql-grpc-comparison.html

Koyeb. "Understanding REST, gRPC, GraphQL, and OpenAPI to Build Your APIs." https://www.koyeb.com/blog/understanding-rest-grpc-graphql-and-openapi-to-build-your-apis

letscountapi.com. "The History of APIs." 2025. https://letscountapi.com/blog/the-history-of-apis

Nordic APIs. "Who Invented the API?" September 20, 2018. https://nordicapis.com/who-invented-the-api/

Nordic APIs. "The Salesforce API Journey: A Deep Dive." March 19, 2025. https://nordicapis.com/the-salesforce-api-journey-a-deep-dive/

OpenAPI Initiative. "FAQ." https://www.openapis.org/faq

Popular Timelines. "Full History of OpenAI in Timeline from 2015." November 9, 2025. https://populartimelines.com/timeline/OpenAI/full

Postman Blog. "Intro to APIs: History of APIs." September 19, 2024. https://blog.postman.com/intro-to-apis-history-of-apis/

Qodex.ai. "The Complete History of the Invention of API." September 2, 2024. https://qodex.ai/blog/history-and-invention-of-api

ReadMe. "The History of REST APIs." January 9, 2025. https://blog.readme.com/the-history-of-rest-apis/

Salesforce Ben. "Salesforce History: Your Guide from 1999 - 2022." December 22, 2023. https://www.salesforceben.com/salesforce-history/

Sensedia. "Tracing the History of APIs: From Mainframes to the Cloud." https://www.sensedia.com/pillar/history-of-apis

Stoplight. "SOAP API." https://stoplight.io/api-types/soap-api

Tailcall. "GraphQL vs OpenAPI: Part 1 of the API Comparison Series." July 29, 2024. https://tailcall.run/blog/graphql-vs-openapi-part-1/

The History of the Web. "SOAP and REST at Odds." October 3, 2023. https://thehistoryoftheweb.com/soap-rest-odds/

The History of the Web. "eBay, APIs, and the Connected Web." October 3, 2023. https://thehistoryoftheweb.com/ebay-apis-connected-web/

Traefik Labs. "The History and Evolution of APIs." October 18, 2024. https://traefik.io/blog/the-history-and-evolution-of-apis

Transparent Data. "Short History of API: From Cabinet to Big BOOM." Medium, July 20, 2022. https://medium.com/transparent-data-eng/short-history-of-api-from-cabinet-to-big-boom-894c56b2c332

Treblle. "From SOAP to REST: Tracing the History of APIs." https://blog.treblle.com/from-soap-to-rest-tracing-the-history-of-apis

Twinword. "Who Launched the First API in History?" July 1, 2024. https://www.twinword.com/blog/who-launched-the-first-api-in-history/

U.S. Supreme Court. Google LLC v. Oracle America, Inc., 593 U.S. 1 (2021).

Wilkes, Maurice V. and David J. Wheeler. The Preparation of Programs for an Electronic Digital Computer. Addison-Wesley, 1951.

Wikipedia. "API." Last modified January 13, 2026. https://en.wikipedia.org/wiki/API

Wikipedia. "Anthropic." Last modified February 2026. https://en.wikipedia.org/wiki/Anthropic

Wikipedia. "GraphQL." Last modified November 2, 2025. https://en.wikipedia.org/wiki/GraphQL

Wikipedia. "OpenAI." Last modified February 2026. https://en.wikipedia.org/wiki/OpenAI

Wikipedia. "SOAP." Last modified October 17, 2025. https://en.wikipedia.org/wiki/SOAP

Wikipedia. "Twilio." Last modified February 2026. https://en.wikipedia.org/wiki/Twilio