The History of the API

Fractional CTO · Founder of Injuria.ai
An application programming interface (API)[1] is the formal boundary that allows distinct software systems to communicate. In modern computing, the API defines the methods, data formats, and protocols that a developer can use to request services from an operating system, a library, or a remote server. The history of the API is the history of software abstraction. Early computers required programmers to understand the physical hardware, writing instructions that manipulated specific memory registers and vacuum tubes. The API emerged as a conceptual boundary, allowing developers to write software without knowing the underlying machine instructions. By establishing a contract between the provider of a service and the consumer of that service, the API enabled the modularity that makes complex software possible.
This evolution proceeded through distinct technical eras, driven by a constant tension between performance and interoperability. The API began as a local construct, a physical catalog of paper tapes used to share subroutines on a single mainframe. As hardware proliferated, the API moved into the operating system, providing a standardized layer that protected the kernel from user-space programs and allowed C code to compile across competing UNIX workstations. When local networks emerged, engineers attempted to stretch these local function calls across the wire, creating distributed object architectures that frequently collapsed under the weight of state management and firewall restrictions.
The internet forced a radical simplification. The transition from tightly coupled binary protocols to stateless, text-based HTTP requests created the web API. This shift transformed the API from a technical implementation detail into a fundamental business model.[12] Today, the API economy allows companies to expose their core competencies as programmable services, enabling the composable architecture of the global digital infrastructure. This article examines the technical constraints, the institutional battles, and the architectural decisions that shaped the API from the 1940s to the 2020s.
The Origins of Abstraction (1940s to 1960s)
The conceptual foundation of the API was laid at the University of Cambridge Mathematical Laboratory in the late 1940s. The Electronic Delay Storage Automatic Calculator (EDSAC)[2] was one of the first practical stored-program computers. It was a massive machine utilizing vacuum tubes for logic and mercury delay lines for memory. EDSAC memory initially consisted of 512 words, but was later expanded to 1024 words. Because memory was so scarce, writing redundant code was impossible. Maurice Wilkes, David Wheeler, and Stanley Gill recognized that mathematical operations like calculating square roots or trigonometric functions would be needed by almost every program. In 1951, they published The Preparation of Programs for an Electronic Digital Computer[3], which detailed the first software library.
The Cambridge team created a physical library of subroutines stored on punched paper tape. To use a subroutine, a programmer would physically retrieve the tape from a metal filing cabinet, copy it, and splice it into their own program tape. Wheeler invented the "Wheeler jump," a programming technique that allowed a program to transfer control to a subroutine and then successfully return to the exact point of departure. As documented by the Computer History Museum[4], Wheeler is generally credited as the first programmer to formally define and make use of the program subroutine. This mechanism was the earliest physical manifestation of an API. It defined a strict input and output contract. The programmer did not need to understand how the square root was calculated, only the format required to pass the numbers to the subroutine and the format in which the answer would be returned.
Throughout the 1950s, software remained inextricably linked to the specific hardware on which it ran. IBM mainframes required different instructions than UNIVAC machines. However, as commercial computing expanded in the 1960s, the cost of rewriting software for every new machine became prohibitive. IBM addressed this with the System/360 in 1964, introducing a family of computers that shared a single instruction set architecture. This allowed software written for a small System/360 to run on a large System/360 without modification. The hardware interface had been standardized, paving the way for software interfaces to follow suit.
During this period, the term "application programming interface" began to crystallize in academic and engineering literature. The concept of abstracting away hardware complexities was gaining traction in the field of remote computer graphics. In 1968, Ira Cotton and Frank Greatorex published a paper on data structures and techniques for remote computer graphics, which is widely cited as one of the earliest formal uses of the term API. Their work at Sperry Rand Corporation and Adams Associates involved designing systems where remote consoles could communicate with a host computer without placing an undue load on the mainframe. They needed a defined interface that separated the application logic from the display hardware. This early usage highlighted the core purpose of an API, which is to serve as a stable boundary between independent systems.
Operating Systems and the System Call Interface (1970s)
The 1970s witnessed the rise of the operating system as the primary manager of hardware resources. Before this era, many programs interacted directly with the hardware, reading and writing to specific memory addresses or controlling peripherals through raw electrical signals. This approach was dangerous and unstable. A single bug in a user program could crash the entire machine. To solve this, operating system designers introduced the concept of protected memory and user space versus kernel space.
The UNIX operating system, developed at Bell Labs by Ken Thompson and Dennis Ritchie, formalized this boundary through the system call interface. UNIX required programs to request hardware access through a specific set of functions. If a program wanted to read a file, it could not access the hard drive directly. Instead, it called the read function provided by the UNIX kernel. The kernel would then validate the request, perform the hardware operation, and return the data to the program. This system call interface was a highly formalized API. It provided a stable, documented set of functions that abstracted away the immense complexity of disk controllers, memory management, and process scheduling.
The development of the C programming language alongside UNIX further solidified the concept of the API. C introduced the standard library, a collection of header files and functions that provided basic capabilities like string manipulation, mathematical operations, and input/output handling. A programmer writing C code would include a header file, which defined the interface for standard functions. The compiler and the linker would then connect the application code to the compiled library code. The header file acted as the API contract.
As UNIX fragmented into various commercial and academic distributions throughout the 1980s, the need for a standardized API became critical. A program written for SunOS might not compile on HP-UX because the underlying system calls or library functions had diverged. To resolve this, the Institute of Electrical and Electronics Engineers formed a committee to define a standard operating system interface. The result was the Portable Operating System Interface (POSIX)[5], first published as IEEE 1003.1 in 1988. POSIX defined a standard C language API for the operating system. If an operating system was POSIX compliant, and a developer wrote a program using only POSIX APIs, that program could be compiled and run on any compliant system. POSIX demonstrated the immense economic value of APIs. By standardizing the interface, the industry decoupled application development from the underlying operating system vendor, fostering a massive ecosystem of portable software.
The Object-Oriented Era and Local APIs (1980s)
While operating systems were standardizing system calls, the methodology of writing software was undergoing a paradigm shift. Procedural programming, which organized code into linear sequences of subroutines, was struggling to manage the complexity of graphical user interfaces and large desktop applications. Object-oriented programming emerged as the solution. Languages like Smalltalk and later C++ organized code into objects, which encapsulated both data and the methods that operated on that data.
In the object-oriented paradigm, the API became the public interface of a class. An object hid its internal state and exposed only specific methods to the outside world. This principle of encapsulation meant that a developer could change the internal implementation of an object without breaking the code that relied on it, provided the public API remained consistent. This local API concept became the foundation of desktop software development in the 1980s and 1990s.
When Apple released the Macintosh in 1984, it included the Macintosh Toolbox, a vast collection of APIs stored in read-only memory. The Toolbox provided developers with the functions needed to draw windows, handle mouse clicks, and manage menus. Instead of writing custom code to draw a scrollbar, a developer simply called the Toolbox API. Microsoft followed a similar path with the Windows API. The Windows API provided a massive library of C functions that allowed developers to interact with the Windows operating system.
These local APIs were incredibly powerful but tightly bound to their specific platforms. A developer could not take a program written for the Windows API and run it on a Macintosh. The API had become a competitive moat. Companies like Microsoft realized that by creating a rich, proprietary API and encouraging developers to build upon it, they could lock both developers and users into their ecosystem. The API was no longer just an engineering abstraction. It was a strategic business asset.
Distributed Computing and the RPC Wars (1980s to 1990s)
As local area networks became common in corporate environments, engineers naturally wanted to extend the concept of the API across the network. If a program could call a function in a local library, it should theoretically be able to call a function on a remote server. This idea gave birth to the Remote Procedure Call (RPC).
Early RPC systems, such as Sun RPC developed by Sun Microsystems in the 1980s, attempted to make network communication look exactly like a local function call. The developer would write a client program that called a stub function. The stub would serialize the parameters into a binary format, send them over the network to the server, wait for the response, deserialize the result, and return it to the client program. The goal was complete transparency. The developer did not need to know about network sockets, packet loss, or byte ordering.
However, network transparency proved to be a dangerous illusion. Local function calls are fast and reliable. Network calls are slow and prone to failure. By hiding the network behind an API that looked like a local call, RPC systems often led developers to write highly inefficient code that made hundreds of network requests to perform simple tasks.
Despite these architectural flaws, the industry pushed forward with distributed object technologies in the 1990s. The goal was to allow object-oriented programs to communicate across networks, regardless of the programming language or operating system. The Object Management Group (OMG)[6] introduced the Common Object Request Broker Architecture (CORBA) in 1991. CORBA was an incredibly ambitious standard. It defined an Interface Definition Language that allowed developers to specify the API of a remote object. A compiler would then generate the necessary client and server stubs in languages like C, C++, or Java.
CORBA promised a utopian vision of interoperability, but it collapsed under its own weight. The specification was massive, complex, and often ambiguous, leading to interoperability failures between different vendor implementations. In addition, CORBA relied on tightly coupled binary protocols that required strict state management between the client and the server. If a network connection dropped, the state was lost, and the application often crashed. Finally, CORBA communicated over arbitrary network ports, which made it fundamentally incompatible with the strict corporate firewalls that were being deployed in the late 1990s to secure networks against the nascent internet.
Microsoft introduced its own competing standard called the Distributed Component Object Model, which suffered from similar complexity and firewall issues. The industry had spent a decade trying to stretch local APIs across the network using tightly coupled binary protocols, and the result was a fragile, unscalable architecture. A completely different approach was required.
The Web, XML, and the Dawn of the API Economy (Late 1990s to Early 2000s)
The rise of the World Wide Web in the mid-1990s provided the foundation for a new type of API. The web was built on the Hypertext Transfer Protocol (HTTP), a simple, stateless, text-based protocol designed for transferring documents. HTTP operated over port 80, which was universally left open by corporate firewalls so employees could browse the web. Engineers quickly realized that if they could tunnel their API calls through HTTP, they could bypass the firewall restrictions that had crippled CORBA.
This realization led to the creation of XML-RPC in 1998, a protocol that encoded remote procedure calls in Extensible Markup Language (XML) and transmitted them via HTTP. XML-RPC was simple and effective, but the enterprise software industry desired a more robust and formalized standard. This led to the development of the Simple Object Access Protocol (SOAP). Backed by Microsoft, IBM, and other major vendors, SOAP expanded upon XML-RPC by adding strict typing, complex security extensions, and a massive ecosystem of supplementary specifications known as WS-*.
SOAP APIs required developers to use the Web Services Description Language to define the API contract. While SOAP solved the firewall problem, it reintroduced the extreme complexity of CORBA. Generating the correct XML payloads required heavy, specialized tooling, and the resulting messages were bloated with metadata, consuming significant network bandwidth.
Despite the technical friction of SOAP, the early 2000s marked the birth of the modern API economy. Companies began to realize that exposing their data and services over the internet could create entirely new business models. Salesforce launched its API on February 7, 2000, becoming one of the first companies to offer enterprise software as a service with a programmable interface. As documented in the history of Salesforce integration architecture[7], this SOAP API allowed customers to extract their customer relationship management data and integrate it with their internal accounting or support systems. Salesforce recognized that an open API would make their platform indispensable to enterprise operations.
eBay launched its API on November 20, 2000, which was not simultaneous with Salesforce's February 2000 launch.[13] eBay was struggling with users writing automated scripts that scraped their website HTML to snipe auctions or list items. Website scraping was fragile because any change to the user interface would break the scripts. By providing a formal API, eBay gave developers a stable, structured way to interact with the marketplace. This allowed third parties to build custom listing tools, inventory management systems, and bidding applications, massively increasing the volume of transactions on the platform. The API had evolved from an internal engineering tool into a public product.[12]
REST and the Programmable Web (2000s to 2010s)
While the enterprise world was busy building complex SOAP architectures, a quieter revolution was taking place in academia. In 2000, Roy Fielding, a principal author of the HTTP specification, published his doctoral dissertation at the University of California, Irvine[8]. The dissertation, titled "Architectural Styles and the Design of Network-based Software Architectures," introduced the Representational State Transfer (REST) architectural style.
Fielding argued that the web itself was the ultimate distributed system, and engineers should stop trying to tunnel legacy RPC concepts through HTTP. Instead, they should embrace the native architecture of the web. REST proposed that APIs should be modeled as resources, identified by Uniform Resource Identifiers (URIs). Clients would interact with these resources using standard HTTP methods like GET, POST, PUT, and DELETE. Most importantly, REST mandated that interactions must be stateless. The server should not store any client context between requests. Every request must contain all the information necessary for the server to understand and process it.
Initially, REST was ignored by the enterprise vendors heavily invested in SOAP. However, the emerging consumer web companies of the mid-2000s embraced it. Companies like Flickr, Twitter, and Amazon Web Services needed APIs that were lightweight, easy to understand, and highly scalable. SOAP was too heavy and required too much tooling for the rapid development cycles of web startups.
Flickr launched its REST API in 2004, allowing developers to easily embed photos into external blogs and applications. Twitter launched its API in 2006, which led to an explosion of third-party mobile clients and analytics tools that drove the early growth of the social network. Amazon Web Services used RESTful principles to expose infrastructure as a service, allowing developers to provision servers and storage via simple HTTP requests.
The shift to REST was accompanied by a shift in data formats. XML was verbose and difficult to parse in web browsers. Douglas Crockford popularized JavaScript Object Notation (JSON), a lightweight data interchange format derived from JavaScript. JSON was vastly simpler than XML and could be parsed natively by web browsers. The combination of REST and JSON became the de facto standard for web APIs, completely displacing SOAP in the public API space by the early 2010s.
The proliferation of public APIs created the programmable web, a paradigm where developers could build applications by mashing up services from different providers. A developer could build a real estate application by combining mapping data from the Google Maps API, property listings from a real estate API, and communication features from the Twilio API. This composability drastically reduced the time and cost required to build software.
However, the open nature of these APIs introduced severe security challenges. Early web APIs often relied on basic authentication, requiring users to hand over their passwords to third-party applications. To solve this, the industry developed the OAuth protocol, which provided a standardized method for token-based authorization. OAuth allowed a user to grant a third-party application limited access to their resources without sharing their password, securing the foundation of the modern API economy.
Modern API Architectures: GraphQL, gRPC, and OpenAPI (2010s to 2020s)
By the mid-2010s, the REST and JSON paradigm was beginning to show its limitations, particularly in the context of mobile application development and microservices architectures. Mobile networks are often slow and unreliable. A mobile application rendering a complex user interface might need to make dozens of separate REST API calls to fetch user profiles, images, comments, and notifications. This problem, known as overfetching and underfetching, resulted in poor application performance and excessive battery drain.
To address this, Facebook developed GraphQL[9], a data query language for APIs. Facebook began developing GraphQL in 2012 to rebuild their native mobile applications and open-sourced it in 2015. Unlike REST, which exposes multiple endpoints for different resources, a GraphQL API exposes a single endpoint. The client sends a query document specifying exactly the data it needs, and the server returns a JSON response containing exactly that data, nothing more and nothing less. This allowed mobile applications to retrieve all necessary data in a single network request. In 2019, the project was moved to the GraphQL Foundation, hosted by the Linux Foundation, ensuring its status as a vendor-neutral standard.
Simultaneously, the backend architecture of large technology companies was shifting from monolithic applications to microservices. In a microservices architecture, a single user request might trigger hundreds of internal API calls between dozens of different services. For these internal communications, the text-based JSON over HTTP/1.1 approach of REST was too slow and consumed too much CPU overhead for parsing.
Google open-sourced gRPC in 2015. gRPC is a high-performance, open-source universal RPC framework. It represents a return to the binary RPC concepts of the 1990s, but built upon modern protocols. gRPC uses HTTP/2 for transport, which supports multiplexing and bidirectional streaming, and Protocol Buffers as the interface description language and binary serialization format. Protocol Buffers are highly compressed and extremely fast to parse. By adopting gRPC, companies could drastically reduce the latency and infrastructure costs of their internal microservices communications.
While GraphQL and gRPC offered specialized solutions, REST remained the dominant architecture for public-facing APIs. However, REST lacked a standardized way to describe the API contract, a feature that SOAP had provided with Web Services Description Language. Developers needed a machine-readable format to document their REST APIs, generate client SDKs, and configure API gateways.
This need was met by the Swagger specification, created in 2010. Swagger provided a JSON or YAML format for describing the endpoints, parameters, and response structures of a REST API. In 2015, SmartBear Software donated the Swagger specification to the Linux Foundation. The donation was announced in 2015, but the specification was officially renamed to the OpenAPI Specification on January 1, 2016[11]. The OpenAPI Initiative, backed by companies like Google, IBM, and Microsoft, formalized the standard. Today, the OpenAPI Specification is the universal language for designing, documenting, and governing REST APIs. It allows organizations to adopt an API-first design methodology, where the API contract is written and agreed upon before any code is implemented.
Conclusion
The evolution of the application programming interface reflects the broader trajectory of computer science. It is a continuous journey toward higher levels of abstraction. What began as a physical paper tape in a Cambridge laboratory evolved into the system call interface of UNIX, the object models of desktop operating systems, and the distributed protocols of the early internet.
The transition to web APIs transformed the API from a purely technical construct into a foundational business asset. The modern digital economy is entirely dependent on the smooth exchange of data between independent organizations, facilitated by REST, GraphQL, and gRPC.[14] By hiding the immense complexity of underlying systems behind stable, documented contracts, APIs have enabled the modular, composable, and globally distributed software architecture that defines the twenty-first century.
Sources (14)
- Wikipedia: application programming interface (API)
- Computer History Museum
- Wikipedia: The Preparation of Programs for an Electronic Digital Computer
- Computer History Museum
- Portable Operating System Interface (POSIX)
- Object Management Group (OMG)
- Salesforce integration architecture
- ics.uci.edu: University of California, Irvine
- GraphQL
- gRPC
- OpenAPI Specification
- Arnaud Lauret, The Design of Web APIs, Second Edition (Simon and Schuster, 2025)
- Paul Reinheimer, Professional Web APIs with PHP (John Wiley and Sons, 2006)
- Lukasz Dynowski, Marcin Dulak, Learning API Styles ("O'Reilly Media, Inc.", 2025)