API Timeline

Pre-Historic

Drums Are Used to Communicate

Long before written language, human communities used drums to send messages across distances too great for the voice to carry, encoding meaning in rhythmic patterns. Talking drums represent one of the earliest examples of transmitting structured information over a shared medium, a precursor to every signaling network that followed.

Historic

Pigeons Are Used to Send Messages

Ancient civilizations including the Persians, Greeks, and Romans used homing pigeons to carry written messages between distant points, establishing some of the first organized long-distance messaging systems. Pigeon post demonstrated the value of reliable message delivery networks centuries before wires and radio made electronic communication possible.

1753

Charles Morrison Says Electricity Can Transmit Messages

In a 1753 letter to the Scots Magazine, a writer identified as Charles Morrison proposed using electricity to transmit messages, suggesting a separate wire for each letter of the alphabet. It was one of the earliest published proposals for electrical telegraphy, planting the idea a full century before practical telegraph networks emerged.

1753

Electrostatic Telegraph

Early experimenters in the mid-eighteenth century proposed and tested telegraph designs that used electrostatic charges sent along wires to signal individual letters. Though impractical for real use, these electrostatic telegraphs proved that electricity could carry intelligible information over distance, laying the conceptual groundwork for electrical communication.

1770

Music box

The music box, which emerged in Switzerland in the late eighteenth century, played tunes encoded as pins on a rotating cylinder that plucked tuned metal teeth. It was an early example of storing a program on a physical medium and executing it mechanically, an idea that would later shape computing.

1775

Electric Telegraph

In the 1770s Georges-Louis Le Sage built a working electrostatic telegraph in Geneva that used twenty-four separate wires, one for each letter of the alphabet, to send messages between rooms. It was among the first functioning electrical telegraphs, demonstrating that electric signals could reliably represent written language.

1790

Barrel Organ

The barrel organ used a rotating wooden cylinder studded with pins to open pipe valves in a fixed sequence, mechanically reproducing a piece of music without a human performer. Like the music box, it encoded a repeatable program in hardware, an early ancestor of stored instructions driving a machine.

1801

Loom

In 1801 Joseph Marie Jacquard demonstrated a loom controlled by chains of punched cards, allowing complex weaving patterns to be changed simply by swapping card sequences. The Jacquard loom separated the machine from its instructions and directly inspired Charles Babbage and later punched-card data processing, making it a foundational moment for programmable machines.

1804

Electrochemical Telegraph

Around 1804 the Spanish scientist Francisco Salva Campillo devised an electrochemical telegraph in which electric current sent over wires produced visible chemical reactions at the receiving end to indicate letters. The design showed that chemistry could make electrical signals readable, an important step toward practical long-distance telegraphy.

1805

Barrel Piano

The barrel piano adapted the pinned-cylinder mechanism of the barrel organ to strike piano strings, letting street musicians play full compositions by turning a crank. It extended the tradition of mechanically encoded music, reinforcing the idea that a sequence of stored instructions could drive complex machine behavior.

1816

First Working Telegraph

In 1816 Francis Ronalds built a working electrostatic telegraph at his home in Hammersmith, sending signals through eight miles of wire strung in his garden. He offered the invention to the British Admiralty, which declined it, but Ronalds had demonstrated that practical electric telegraphy over meaningful distances was achievable.

1822

Charles Babbage takes first steps in the construction of machines that would compute numbers

In 1822 Charles Babbage proposed his Difference Engine, a mechanical device for automatically calculating and printing mathematical tables, and began work on its construction with British government funding. The project marked the first serious attempt to build a machine that could compute numbers without human intervention.

1822

Steam Calculator

Babbage envisioned his calculating engines as machines that could be driven by steam power, famously wishing that tedious astronomical calculations could be executed by steam. The notion of harnessing industrial power to perform computation captured the era's ambition to mechanize mental labor the way steam had mechanized physical labor.

1830

Steam Locomotive

The opening of the Liverpool and Manchester Railway in 1830 proved steam locomotives could move people and goods on a scheduled, commercial scale. Railroads created urgent demand for fast signaling along their lines, and the telegraph would grow up alongside the tracks, tying transportation and communication networks together.

1837

Charles Babbage published a paper describing a mechanical computer that is now known as the Analytical Engine

In 1837 Charles Babbage described the Analytical Engine, a general-purpose mechanical computer with a separate store for data and mill for processing, programmed by punched cards borrowed from the Jacquard loom. Though never completed, its architecture anticipated the essential structure of modern computers by more than a century.

1839

First Commercial Telegraph (Railway)

In 1839 the Cooke and Wheatstone telegraph entered commercial service along the Great Western Railway between Paddington and West Drayton, spanning thirteen miles. It was the first telegraph used commercially, proving that electrical messaging could be a paying service and that railways and telegraphy were natural partners.

1842

Punch Tape Player Pianos

In 1842 the Frenchman Claude Felix Seytre patented a design for playing musical instruments automatically from perforated cards, an approach that evolved into the perforated paper rolls of player pianos. Encoding music as punched holes read by a machine was a direct mechanical ancestor of punched-tape data storage.

1843

Ada Lovelace first describes what is known as a computer and its software

In 1843 Ada Lovelace published her notes on Babbage's Analytical Engine, including a step-by-step method for computing Bernoulli numbers that is widely regarded as the first published computer program. She also recognized that such a machine could manipulate symbols beyond numbers, anticipating general-purpose computing and software itself.

1844

First Long Distance Telegraph Message

On May 24, 1844, Samuel Morse sent the message What hath God wrought over a new telegraph line from Washington to Baltimore. The demonstration convinced the public and Congress that near-instant long-distance communication was practical, launching the rapid buildout of telegraph networks across the United States.

1844

Innocenzo Manzetti Modeled Speaking Telegraph

In 1844 the Italian inventor Innocenzo Manzetti first proposed the idea of a speaking telegraph, a device that could carry the human voice over wires. Decades before Bell's patent, Manzetti's concept showed that inventors were already imagining the leap from coded telegraph signals to transmitted speech.

1846

Punch Tape Telegrams

Alexander Bain developed a system in which telegraph messages were punched onto paper tape in advance and then transmitted automatically at high speed, far faster than a human operator could key. Punched tape decoupled message preparation from transmission and became a standard data medium for telegraphy and, later, computing.

1846

Printing Telegraph

In 1846 Royal Earl House patented a printing telegraph that let operators send messages from a piano-style keyboard and receive them printed as letters rather than code. By removing the need for trained Morse operators on the receiving end, it pointed toward the teleprinter and machine-readable text communication.

1847

Paper Roll Traveling Valve Reed Organ

Mid-nineteenth-century instrument makers developed reed organs that read music from perforated paper rolls passing over a traveling valve mechanism, with holes in the paper admitting air to sound specific notes. The perforated roll refined the idea of a continuous punched medium carrying stored instructions, later echoed in paper-tape computing.

1851

Morse Code

In 1851 a modified version of Morse's code, later known as International Morse Code, was adopted as the standard for telegraphy across continental Europe. A shared encoding scheme allowed different operators, companies, and countries to interoperate on the wire, an early demonstration of why communication standards matter.

1854

Principes of the Telephone

In 1854 the French telegraph engineer Charles Bourseul published an article describing how speech might be transmitted electrically by making and breaking a circuit with a vibrating diaphragm. Though he never built a device, his paper laid out the operating principle later realized in working telephones.

1860

Panetelegraph

The pantelegraph, developed by the Italian physicist Giovanni Caselli, transmitted handwritten text and images over ordinary telegraph lines using synchronized scanning pendulums. Placed into commercial service in France in the 1860s, it was effectively the first fax system, proving that pictures as well as code could travel by wire.

1861

First Speech-Transmitting Telephone

In 1861 the German inventor Philipp Reis demonstrated his Reis telephone, a device that converted sound into electrical impulses and transmitted recognizable tones and fragments of speech over wire. Though imperfect, it was the first apparatus to transmit speech electrically, fifteen years before Bell's patented telephone.

1871

Intent to Invent Sound Telegraph

In 1871 the Italian-American inventor Antonio Meucci filed a patent caveat, a formal notice of intent to patent, for his sound telegraph, a device for transmitting voice over wires. Unable to afford a full patent, Meucci let the caveat lapse, and his early claim became central to later disputes over the telephone's invention.

1876

Bell Patents Telephone

In March 1876 the United States Patent Office granted Alexander Graham Bell a patent for the telephone, covering the method of transmitting vocal sounds telegraphically. Often called one of the most valuable patents ever issued, it anchored the Bell System and the commercial telephone industry that grew from it.

1876

Bell sends "Mr. Watson, come here! I want to see you!"

On March 10, 1876, Alexander Graham Bell spoke the first intelligible sentence transmitted by telephone, calling his assistant Thomas Watson from an adjoining room. The moment marked the transition from imagining voice transmission to achieving it, opening the era of real-time spoken communication over electrical networks.

1877

First Telephone Exchange in Boston

In 1877 Edwin Holmes connected telephones to his existing burglar-alarm wiring in Boston, creating an early switchboard that allowed multiple subscribers to be interconnected. The exchange concept, in which any subscriber could be connected to any other through a central switch, became the defining architecture of telephone networks.

1877

First long-distance telephone line

In 1877 the Ridge Telephone Company strung a roughly sixty-mile telephone line between French Corral and French Lake in California to coordinate hydraulic mining operations. It demonstrated within a year of Bell's patent that the telephone could serve practical long-distance business communication, not just local conversation.

1880

Scanning Phototelegraph

Around 1880 the English physicist Shelford Bidwell demonstrated scanning phototelegraphy, using the light-sensitive element selenium to scan an image and transmit it electrically. His work established the scanning principle, breaking an image into sequential signals, that underlies fax machines, television, and digital imaging.

1887

Multiplex Switchboard

The Hungarian engineer Tivadar Puskas, who had earlier proposed the telephone exchange itself, introduced the multiplex switchboard in 1887, allowing many more calls to be handled and interconnected efficiently. Improved switching capacity was essential to scaling telephone networks from local novelties into city-wide and national systems.

1888

Telautograph

In 1888 Elisha Gray patented the telautograph, a device that transmitted handwriting over telegraph wires by electrically reproducing the movements of a pen at a distant receiver. It extended wire communication beyond coded text to reproduce human gestures remotely, foreshadowing later facsimile and remote-input technologies.

1888

Hertz Detects Radio Waves

In 1888 the German physicist Heinrich Hertz experimentally generated and detected electromagnetic waves, confirming James Clerk Maxwell's theoretical predictions. His proof that invisible waves could travel through space and be detected at a distance provided the scientific foundation for radio, wireless telegraphy, and ultimately all wireless networking.

1890

Punch Cards

For the 1890 United States Census, Herman Hollerith deployed an electric tabulating system that read data from punched cards, completing in months work that had previously taken years. Punched cards became the dominant medium for machine-readable data for decades, and Hollerith's company became a forerunner of IBM.

1899

Marconi Establishes Radio Link Between England and France

In 1899 Guglielmo Marconi transmitted wireless telegraph signals across the English Channel between England and France, the first international radio link. The demonstration showed that communication no longer required physical wires between endpoints, opening the way for maritime radio, broadcasting, and eventually wireless data networks.

1904

First Radio Transmission of Music

In 1904 the Austrian experimenter Otto Nussbaumer achieved one of the first wireless transmissions of music, sending a sung folk tune between rooms at the technical university in Graz. Transmitting music rather than coded signals showed that radio could carry rich audio content, hinting at broadcasting's future.

1906

First Radio Program of Voice and Music in US

On Christmas Eve 1906 Reginald Fessenden transmitted a program of speech and music from Brant Rock, Massachusetts, reportedly heard by ship wireless operators along the Atlantic coast. Widely cited as the first radio broadcast of voice and music in the United States, it inaugurated radio as a mass communication medium.

1908

Radiofax

In the early 1900s inventors began transmitting photographs and documents wirelessly, with Hans Knudsen demonstrating radio facsimile transmission around 1908. Radiofax combined the scanning principles of the phototelegraph with wireless transmission, extending image communication beyond the reach of wires and later serving newspapers, weather services, and the military.

1911

IBM

In 1911 the Computing-Tabulating-Recording Company was formed by merging several firms, including Herman Hollerith's punched-card tabulating business, and was renamed International Business Machines in 1924. IBM would dominate data processing for much of the twentieth century and shape mainframe computing, on which early enterprise integration was built.

1914

WWI

The First World War, beginning in 1914, drove rapid advances in radio, field telephony, and cryptography as armies depended on fast, secure communication across vast fronts. Wartime investment accelerated electronics and signaling technology and trained a generation of engineers who would build the interwar communication industries.

1919

ShortWave Radio

Following the First World War, experimenters discovered that shortwave frequencies could travel thousands of miles by reflecting off the ionosphere, enabling intercontinental radio communication with modest transmitter power. Shortwave made global point-to-point wireless links practical and affordable, dramatically shrinking the communicating world.

1927

First Transatlantic Telephone Call

In January 1927 commercial telephone service opened between New York and London, carried by longwave radio, with the first official transatlantic call placed between AT&T and the British General Post Office. Voice communication across the ocean, though expensive, connected the business capitals of two continents in real time.

1932

Drum Memory

In 1932 the Austrian engineer Gustav Tauschek invented drum memory, which stored data as magnetized spots on the surface of a rotating cylinder. Magnetic drums became a principal form of working storage in early computers of the 1950s, a step toward the memory hierarchies of modern machines.

1933

Telex Messaging

In 1933 the German Reichspost opened its Telex service, a switched network of teleprinters that let subscribers dial one another and exchange typed messages directly. Telex grew into a global text messaging network for business and government, an important precursor to electronic mail and machine-to-machine messaging.

1934

FCC Founded

The Communications Act of 1934 created the Federal Communications Commission to regulate interstate and international communication by wire and radio in the United States. Consolidating oversight of telephone, telegraph, and broadcasting under one agency, the FCC shaped how communication networks were built, priced, and interconnected for decades.

1935

FM Radio

In 1935 Edwin Armstrong publicly demonstrated frequency modulation, a method of radio transmission that greatly reduced static and delivered far higher audio fidelity than AM. FM proved that modulation techniques could dramatically improve the quality and reliability of wireless communication, a lesson later central to data transmission.

1936

Turing Machine

In 1936 Alan Turing published On Computable Numbers, defining an abstract machine that could carry out any computation expressible as an algorithm. The Turing machine gave computing its theoretical foundation, establishing the concept of a universal programmable machine before any electronic computer existed.

1937

Harvard Mark 1

In 1937 Howard Aiken proposed the design of a large-scale automatic calculating machine, which IBM built as the Harvard Mark I and delivered in 1944. The electromechanical computer executed long sequences of operations from punched paper tape, realizing much of Babbage's vision and advancing programmable computation.

1939

Hewlett Packard

In 1939 Bill Hewlett and David Packard founded Hewlett-Packard in a Palo Alto garage, initially selling audio oscillators. The company became a cornerstone of the electronics industry and its founding is often treated as the symbolic birth of Silicon Valley, the region that would later drive computing and the web.

1939

WWII

The Second World War, beginning in 1939, spurred enormous investment in electronics, radar, cryptanalysis, and automatic computation, producing machines such as Colossus and funding ENIAC. Wartime urgency compressed decades of computing progress into a few years and established government as a major sponsor of computer research.

1941

Store Information In Memory

In the early 1940s pioneering machines such as Konrad Zuse's Z3 and the Atanasoff-Berry Computer demonstrated that a computing device could hold numbers in electronic or electromechanical memory while it worked. Storing information in memory rather than on external media was a defining step toward the modern computer.

1943

ENIAC

Construction of ENIAC began in 1943 at the University of Pennsylvania under a United States Army contract to compute artillery firing tables. Completed in 1945, it was the first general-purpose electronic digital computer, thousands of times faster than electromechanical machines and proof that electronic computation worked at scale.

1946

UNIVAC

In 1946 ENIAC designers J. Presper Eckert and John Mauchly left the University of Pennsylvania to build a commercial computer, work that produced the UNIVAC I, delivered to the Census Bureau in 1951. UNIVAC moved computing out of the laboratory and into business and government data processing.

1947

Transistor

In December 1947 John Bardeen, Walter Brattain, and William Shockley demonstrated the first transistor at Bell Labs. The solid-state device replaced bulky, unreliable vacuum tubes and became the fundamental building block of all modern electronics, making small, cheap, and powerful computers and communication equipment possible.

1948

Mathematical Theory of Communication

In 1948 Claude Shannon published A Mathematical Theory of Communication, defining information in measurable units and establishing the limits of transmitting data over noisy channels. Information theory gave engineers the mathematics behind every digital communication system, from modems to the protocols that carry API traffic today.

1949

Memex (Linked Documents)

Vannevar Bush's Memex concept described a desk-sized device that would store a personal library on microfilm and let its user create associative trails linking documents together. The vision of navigating knowledge through links directly inspired the pioneers of hypertext and, through them, the World Wide Web.

1949

Computer Talks Over Phone

In the late 1940s engineers demonstrated that computing equipment could exchange data over ordinary telephone lines, building on George Stibitz's earlier remote operation of a calculator by teletype. Using the existing voice network to carry machine data foreshadowed modems and the dial-up links that first connected computers together.

1953

COBOL

In the early 1950s Grace Hopper developed compilers and argued that programs should be written in English-like statements rather than machine code, work that led to FLOW-MATIC and ultimately COBOL in 1959. COBOL standardized business programming across different manufacturers' machines, an early triumph of portable, shared software conventions.

1954

FORTRAN

In 1954 John Backus and his IBM team began developing FORTRAN, the first widely used high-level programming language, released in 1957. By letting scientists and engineers write formulas instead of assembly code, FORTRAN proved that compilers could produce efficient programs and made computing accessible far beyond specialists.

1957

Sputnik

The Soviet Union's launch of Sputnik in October 1957 shocked the United States into a massive expansion of science and technology funding, including the creation of ARPA in 1958. ARPA would go on to sponsor the ARPANET, the direct ancestor of the internet on which web APIs run.

1958

Digital Phone Lines

In 1958 Bell introduced the first commercial modems, developed for the SAGE air defense system, allowing digital data to travel over the analog telephone network. Turning the ubiquitous phone system into a data carrier meant computers could be connected anywhere lines already ran, seeding decades of dial-up networking.

1958

Integrated Circuit

In 1958 Jack Kilby at Texas Instruments demonstrated the first integrated circuit, with Robert Noyce independently developing a practical silicon version soon after. Placing many electronic components on a single chip launched the relentless miniaturization and cost reduction, later described by Moore's Law, that made ubiquitous computing possible.

1959

Semi-Automatic Ground Environment (SAGE) Wide Area Network

SAGE, the United States air defense system that became operational in the late 1950s, linked radar sites and command centers to large computers over telephone lines across the continent. It was the first large-scale computer network, pioneering modems, real-time processing, and interactive displays that shaped later commercial networking.

1960

Object Oriented Programming

In the early 1960s the ideas behind object-oriented programming began to take shape, culminating in the Simula language developed by Ole-Johan Dahl and Kristen Nygaard. Organizing software around objects that bundle data with behavior and expose defined interfaces became a foundational pattern for reusable code and, conceptually, for APIs.

1961

Computer Time Sharing

In 1961 MIT demonstrated the Compatible Time-Sharing System, which let multiple users work interactively on a single computer at the same time through separate terminals. Time-sharing transformed computers from batch-job machines into shared, interactive resources and directly motivated early computer networking and remote access.

1962

Telstar satellite transmits the first TV picture

In July 1962 the Telstar 1 satellite relayed the first live transatlantic television pictures, along with telephone calls and data, between the United States and Europe. Telstar demonstrated that satellites could carry high-bandwidth communication across oceans, adding an orbital layer to the world's growing communication infrastructure.

1962

Database

In the early 1960s the term database came into use as organizations began consolidating machine-readable records into centrally managed, shared collections of data. Treating data as a durable, structured resource independent of any single program set the stage for database management systems and, eventually, for data served through APIs.

1963

Hypertext (Ted Nelson)

Around 1963 Ted Nelson coined the term hypertext to describe bodies of written material connected by links that readers could follow in nonsequential paths. The concept, publicly presented in 1965, provided the intellectual blueprint for linked information systems and directly influenced the design of the World Wide Web.

1963

Hypermedia (Ted Nelson)

Alongside hypertext, Ted Nelson coined hypermedia to describe linked networks of not just text but images, audio, and video. Extending linking to all media types anticipated the multimedia web, and the hypermedia idea later resurfaced in API design through concepts such as hypermedia controls in REST.

1964

Mouse

In 1964 Douglas Engelbart and his team at the Stanford Research Institute built the first computer mouse, a wooden prototype for pointing at objects on a screen. The mouse made direct, intuitive interaction with graphical information possible and became a defining input device of personal computing.

1964

GUI

In the mid-1960s Douglas Engelbart's Augmentation Research Center developed the interactive techniques, including windows, pointing, and on-screen text manipulation, that grew into the graphical user interface. The GUI abstracted the machine behind visual representations, the same separation of interface from implementation that APIs provide for software.

1964

Electronic File System

By the mid-1960s operating systems for disk-based computers introduced electronic file systems that organized stored information into named files and directories that programs could reliably create, read, and share. The file system gave software a standard interface to persistent data, an early and enduring example of a programmatic contract.

1964

Sync Satellite Television Network

In 1964 the Syncom 3 satellite reached geostationary orbit and relayed live television from the Tokyo Olympics to the United States. A satellite that stayed fixed over one point on Earth enabled continuous broadcast and communication networks, establishing the geostationary architecture used by global telecommunications for decades.

1964

IBM SABRE Reservation System

By 1964 the SABRE system, built by IBM for American Airlines, was processing airline reservations in real time over a network of terminals spanning the country. SABRE was the first large commercial real-time transaction network, demonstrating the business model of remote programmatic access to a central system.

1965

CODASYL Database

In the mid-1960s the CODASYL committee, building on Charles Bachman's Integrated Data Store, began defining the network database model and standard languages for describing and manipulating shared data. This standardization effort treated data access as a formal, specified interface, an important conceptual ancestor of database APIs.

1966

Xerox unveils the first fax machine

In 1966 Xerox introduced the Magnafax Telecopier, a compact facsimile machine that transmitted documents over ordinary telephone lines in about six minutes per page. It brought document transmission out of specialized telegraph offices and into ordinary businesses, normalizing the exchange of documents across the phone network.

1966

Michigan Educational Research Information Triad (MERIT)

In 1966 Michigan's three major research universities formed the MERIT consortium to link their mainframe computers into a shared network. One of the earliest regional academic networks, MERIT proved universities could pool computing resources over telecommunication lines and later played a key role in operating the NSFNET backbone.

1967

First ATM is installed in London

In 1967 Barclays installed the first automated teller machine at its Enfield branch in London, letting customers withdraw cash without a human teller. The ATM was an early example of a machine exposing a business function to the public on demand, foreshadowing the self-service, programmatic access to services that APIs would later provide.

1967

Melvin Conway introduces what is later called Conways Law

In 1967 computer scientist Melvin Conway observed that organizations design systems that mirror their own communication structures, a principle later dubbed Conways Law. The idea became foundational to software architecture, explaining why team boundaries end up shaping the boundaries of services and APIs in distributed systems.

1968

Multiplexing

In the late 1960s researchers refined multiplexing techniques that allow multiple data streams to share a single communication channel. Multiplexing made efficient use of expensive network links possible and became a core building block of packet-switched networks like ARPANET and, eventually, the Internet.

1968

The Mother of All Demos by Douglas Engelbart

On December 9, 1968 Douglas Engelbart demonstrated his oN-Line System in San Francisco, showing the mouse, hypertext, windows, video conferencing, and collaborative editing in a single session. Later called the Mother of All Demos, it previewed interactive, networked computing decades before those ideas reached the mainstream.

1969

UNIX

In 1969 Ken Thompson and Dennis Ritchie began developing UNIX at Bell Labs, a portable, multiuser operating system built from small composable tools. UNIX conventions such as pipes, files, and simple interfaces deeply influenced how programmers think about modularity and shaped the server environments that would later host web APIs.

1969

Moon Landing

On July 20, 1969 Apollo 11 landed humans on the Moon, guided by the Apollo Guidance Computer, one of the earliest computers built from integrated circuits. The program demonstrated real-time computing and disciplined software engineering at scale, accelerating investment in the technologies underlying modern computing.

1969

Mass produced software components By McIlroy, Malcolm Douglas

At the 1968 NATO Software Engineering Conference, Douglas McIlroy proposed an industry of mass-produced, reusable software components, published in the 1969 proceedings. His vision of assembling systems from standard parts anticipated software libraries, package managers, and ultimately APIs as reusable, well-defined interfaces.

1969

Host Software The First RFC

In April 1969 Steve Crocker wrote RFC 1, titled Host Software, describing how ARPANET host computers should communicate. It launched the Request for Comments series, the open, collaborative documentation process through which Internet protocols and standards have been defined ever since.

1969

ARPANET Four Initial Nodes Established

By December 1969 ARPANET connected its first four nodes at UCLA, Stanford Research Institute, UC Santa Barbara, and the University of Utah. This packet-switched research network was the direct ancestor of the Internet, proving that distant computers could exchange data over shared infrastructure.

1969

Compuserve

Founded in 1969 in Columbus, Ohio, CompuServe sold time-sharing access to mainframe computers and later grew into the first major commercial online service for consumers. It demonstrated there was a real market for remote, networked computing services long before the web existed.

1970

Intel

By 1970 Intel, founded by Robert Noyce and Gordon Moore, was shipping semiconductor memory chips and would introduce the first commercial microprocessor, the 4004, the following year. Intel processors became the engines of personal computers and the servers that would later run the Internet.

1970

QUEL Query Language

QUEL was a relational database query language created for the Ingres project at the University of California, Berkeley, building directly on E.F. Codd's relational model. Though later overtaken by SQL, QUEL demonstrated that data could be retrieved through declarative queries rather than hand-written navigation code.

1970

DRAM

In 1970 Intel introduced the 1103, the first commercially available dynamic random-access memory chip. DRAM replaced magnetic core memory with cheaper, denser semiconductor storage, driving down the cost of computing and enabling generations of ever more capable machines.

1970

ARPANET Reaches East Coast (MIT)

In 1970 ARPANET expanded to the East Coast, adding nodes at institutions including MIT, Harvard, and BBN. The coast-to-coast growth showed the network could scale geographically and connected the leading computing research centers of the United States into one system.

1971

Floppy Disk

IBM introduced the 8-inch floppy disk in 1971 as a portable, inexpensive medium for loading software and moving data between machines. The floppy became the standard way to distribute programs and files for two decades, helping make software itself a shippable product.

1971

Email

In 1971 Ray Tomlinson sent the first networked email between machines on ARPANET, choosing the @ symbol to separate user from host. Email quickly became the network's killer application, proving that connecting computers was really about connecting people, and it remains a foundational messaging pattern.

1971

File Transfer Protocol (FTP)

The File Transfer Protocol was first specified in 1971 by Abhay Bhushan as RFC 114, defining a standard way to move files between hosts on ARPANET. FTP was one of the earliest application-level protocols, establishing the pattern of standardized interfaces for exchanging data across networks.

1971

TELNET

TELNET, specified in 1971, let users log into remote computers over ARPANET as though sitting at a local terminal. It was among the first application protocols and demonstrated that computing power could be consumed remotely across a network, a precursor to modern remote services.

1971

ARPANET Has 23 nodes

By 1971 ARPANET connected 23 hosts at universities and research centers across the United States. The steady growth validated packet switching as a practical networking technology and expanded the community of researchers building protocols and applications on top of the network.

1972

Relational Database Model

E.F. Codd of IBM proposed the relational model, organizing data into tables that could be queried declaratively rather than navigated procedurally. Introduced in his landmark paper A Relational Model of Data for Large Shared Data Banks, it became the foundation of virtually every database that sits behind modern APIs.

1972

ARPANET Has 29 nodes

By 1972 ARPANET had grown to 29 nodes, and that year the network was publicly demonstrated at the International Conference on Computer Communication in Washington. The demonstration convinced many skeptics that packet-switched networking actually worked and drew new institutions into the project.

1973

Ethernet

In 1973 Robert Metcalfe and David Boggs at Xerox PARC invented Ethernet, a method for connecting computers over a shared local network. Ethernet became the dominant local area networking standard, wiring together the offices and data centers on which networked software depends.

1973

GPS Project Begins

In 1973 the United States Department of Defense approved the Navstar Global Positioning System project, consolidating earlier satellite navigation programs. GPS later opened to civilian use and became critical infrastructure, with location data eventually flowing into countless applications through mapping and geolocation APIs.

1973

SEQUEL Query Language

Donald Chamberlin and Raymond Boyce at IBM designed SEQUEL, a structured English query language for retrieving data from relational databases. Later shortened to SQL, it became the universal language for querying data and one of the most widely used interfaces in all of computing.

1973

ARPANET Has 40 nodes

By 1973 ARPANET had roughly 40 nodes and made its first international connections, linking to Norway and then London. The network was no longer a domestic experiment but the seed of a global communications system.

1974

ARPANET Has 46 nodes

By 1974 ARPANET connected 46 nodes, and its growing traffic was exposing the limits of the original host-to-host protocol. The pressure of scale motivated work on a new internetworking protocol capable of joining many separate networks together.

1974

Transmission Control Program (TCP)

In 1974 Vint Cerf and Robert Kahn published A Protocol for Packet Network Intercommunication, describing the Transmission Control Program for reliably exchanging data across interconnected networks. Their design, later split into TCP and IP, became the fundamental protocol suite of the Internet.

1974

Systems Network Architecture (SNA)

In 1974 IBM released Systems Network Architecture, a proprietary framework for connecting terminals and mainframes across enterprise networks. SNA dominated corporate networking for years, and the industry's eventual migration from such closed, vendor-specific systems to open protocols like TCP/IP shaped lasting expectations for open standards.

1975

ARPANET Has 57 Modes

By 1975 ARPANET had grown to 57 nodes and was transferred to the Defense Communications Agency as an operational network rather than a research experiment. The transition marked packet-switched networking's move from laboratory project to working infrastructure.

1975

Microsoft

In 1975 Bill Gates and Paul Allen founded Microsoft to sell a BASIC interpreter for the Altair 8800. The company grew into the dominant supplier of personal computer software, and its operating systems and developer tools defined the platforms and programming interfaces used by a generation of developers.

1975

Altair 8080

The MITS Altair 8800, built around the Intel 8080 processor, launched in 1975 and is widely credited with sparking the personal computer revolution. Sold as a kit to hobbyists, it created the first mass market for microcomputer software.

1975

First Edition of Fred Brooks Mythical Man Month published

In 1975 Fred Brooks published The Mythical Man-Month, drawing on his experience managing IBM's OS/360 operating system project. Its lessons, including that adding people to a late software project makes it later, became enduring wisdom about the human side of building large software systems.

1976

Entity-Relationship Databases

In 1976 Peter Chen published the entity-relationship model, giving designers a way to diagram data as entities, attributes, and relationships. ER modeling became a standard technique for database design, shaping how organizations structure the data that applications and APIs later expose.

1976

Apple

In 1976 Steve Jobs, Steve Wozniak, and Ronald Wayne founded Apple Computer and released the Apple I. Apple helped turn the personal computer into a consumer product, and its later platforms and developer ecosystems made application programming interfaces central to mainstream software distribution.

1976

CYCLADES Computer Network

CYCLADES, a French research network directed by Louis Pouzin, pioneered the datagram and the principle that hosts, not the network itself, should ensure reliable delivery. Its end-to-end design directly influenced Cerf and Kahn's work on TCP/IP and thus the architecture of the Internet.

1976

X.25 Packet Switching Protocol

In 1976 the international telecommunications standards body CCITT approved X.25, a protocol suite for packet-switched networks operated by telephone carriers. X.25 powered early public data networks worldwide, and although eventually displaced by TCP/IP, it proved that commercial packet-switched data services were viable.

1977

TRS-80

In 1977 Tandy released the TRS-80 through its Radio Shack stores, one of the first mass-market, fully assembled personal computers alongside the Apple II and Commodore PET. Affordable and widely distributed, it brought computing and programming into homes and small businesses.

1978

WordStar

Released in 1978, WordStar became the dominant word processing program of the early microcomputer era. It demonstrated that personal computers could replace dedicated office equipment, helping establish productivity software as a driving force behind business adoption of computing.

1979

Oracle Database

In 1979 Relational Software, the company later renamed Oracle, shipped the first commercially available SQL-based relational database management system. Oracle's success commercialized Codd's relational model and helped make SQL databases the standard back end for enterprise applications and, later, web APIs.

1979

First Commercial Cellular Network

In 1979 Nippon Telegraph and Telephone launched the first commercial cellular network in Tokyo. Cellular telephony began the untethering of communications from fixed lines, a trajectory that would eventually put networked, API-driven computers in billions of pockets.

1979

dBase Desktop Database

dBase, published by Ashton-Tate, brought database management to personal computers, letting small businesses store and query structured data without a mainframe. Its success established the desktop database category and introduced millions of users to programmatic manipulation of data.

1980

USENET

USENET, created by Duke University graduate students Tom Truscott and Jim Ellis, linked computers over dial-up connections to distribute threaded discussion groups. It grew into a global, decentralized forum that pioneered many of the community dynamics later seen on the web and social platforms.

1981

ARPANET Has 213 Nodes

By 1981 ARPANET had grown to 213 host computers, with a new host connecting roughly every twenty days. The accelerating growth strained the network's original protocols and set the stage for the coming transition to TCP/IP.

1981

TCP/IP

In 1981 the TCP/IP protocols were formalized in RFCs 791 and 793, splitting the design into the Internet Protocol for routing packets and the Transmission Control Protocol for reliable delivery. This layered suite became the common language of the Internet and of every web API built on it.

1982

CDROM

Sony and Philips introduced the compact disc in 1982, launching optical storage for digital audio. The same technology was soon adapted to store computer data as CD-ROM, offering hundreds of megabytes of read-only storage on an inexpensive disc.

1982

Compaq

In 1982 Rod Canion, Jim Harris, and Bill Murto founded Compaq, which legally reverse engineered the IBM PC BIOS to build fully compatible computers. Compaq legitimized the PC clone market, turning the IBM PC design into an open industry standard rather than a single vendor's product.

1982

Simple Mail Transfer Protocol (SMTP)

In 1982 Jon Postel published RFC 821, defining the Simple Mail Transfer Protocol for relaying email between servers. SMTP standardized message exchange across the Internet and remains the backbone of email delivery more than four decades later.

1983

ARPANET Switches to TCP/IP

On January 1, 1983 ARPANET switched from the older NCP protocol to TCP/IP in a coordinated flag day cutover. The transition is widely regarded as the operational birth of the Internet, since TCP/IP allowed many separate networks to interconnect as one.

1983

Lotus 123

Released in 1983, Lotus 1-2-3 combined spreadsheet, charting, and database features and quickly became the killer application for the IBM PC. Its success drove businesses to buy personal computers in volume, cementing the PC's place in the enterprise.

1983

IPV4

Internet Protocol version 4, specified in RFC 791 and deployed with the 1983 ARPANET transition, defined the 32-bit addressing scheme that identifies devices on the Internet. IPv4 has carried the vast majority of Internet traffic ever since, despite the eventual exhaustion of its address space.

1983

Berkely Sockets

The 1983 release of 4.2BSD UNIX included the Berkeley sockets API, giving programmers a standard set of functions for network communication. Sockets became the canonical programming interface for TCP/IP and an early, influential example of an API abstracting away complex infrastructure.

1984

CD-ROM

Sony and Philips published the Yellow Book standard defining CD-ROM, adapting the audio compact disc to store computer data. A single disc held roughly 650 megabytes, transforming the distribution of software, encyclopedias, and large datasets in the years before broadband networks.

1984

Domain Name System (DNS)

Paul Mockapetris designed the Domain Name System, a distributed, hierarchical directory that translates human-readable names into numeric network addresses. DNS replaced the centrally maintained hosts file and made the Internet navigable and scalable, underpinning every URL and API endpoint in use today.

1984

Dynamic Host Configuration Protocol (DHCP)

The Dynamic Host Configuration Protocol and its predecessors such as BOOTP were developed to automatically assign network addresses and configuration to devices joining a network. Automatic configuration removed manual setup as a barrier, making it practical to connect large numbers of machines to growing networks.

1984

Open Systems Interconnect (OSI)

The International Organization for Standardization published the Open Systems Interconnection reference model, describing network communication in seven layers from physical media up to applications. Though TCP/IP won in practice, the OSI model remains the standard vocabulary for teaching and reasoning about network architecture.

1985

Windows

In 1985 Microsoft shipped Windows 1.0, a graphical environment running on top of MS-DOS. Windows evolved into the dominant desktop operating system, and its Win32 programming interface became one of the most widely targeted APIs in the history of software.

1985

Dell beings assembling made to order computers

Michael Dell's young company began building computers to order and selling them directly to customers, bypassing retail channels. The direct, build-to-order model drove down prices and showed how customization and logistics could reshape the technology supply chain.

1985

symbolics.com

On March 15, 1985 computer maker Symbolics registered symbolics.com, the first .com domain name on the Internet. The registration marked the quiet beginning of the commercial domain namespace that would explode with the arrival of the web a decade later.

1985

Whole Earth Lectronic Link (WELL)

Founded in 1985 by Stewart Brand and Larry Brilliant, the Whole Earth Lectronic Link was a pioneering dial-up online community based in the San Francisco Bay Area. The WELL demonstrated the social power of computer-mediated conversation and influenced how later online communities were imagined and built.

1985

National Science Foundation Network (NSFNET)

The National Science Foundation established NSFNET to link its supercomputing centers and regional academic networks using TCP/IP. NSFNET became the Internet's principal backbone, opening the network to researchers beyond defense projects and paving the way for eventual commercial use of the Internet.

1986

386 Computer

In 1986 Compaq shipped the Deskpro 386, the first personal computer built on Intel's 32-bit 80386 processor. The 386's protected mode and larger memory space made true multitasking operating systems possible on commodity hardware, expanding what personal computers could do.

1987

Transport Layer Interface (TLI)

The Transport Layer Interface, introduced with AT&T's UNIX System V, offered a protocol-independent programming interface to network transport services. TLI competed with Berkeley sockets as a standard networking API, illustrating early industry efforts to abstract networking behind stable programming interfaces.

1987

Microsoft Excel

Microsoft Excel, first released for the Macintosh and brought to Windows in 1987, became the leading spreadsheet application. Excel put data analysis on every business desktop, and its macro and automation interfaces made it one of the most programmed-against applications in the world.

1987

VisiCalc

VisiCalc, created by Dan Bricklin and Bob Frankston, was the first electronic spreadsheet and the original killer application for personal computers. It gave businesses a compelling reason to buy microcomputers and established the spreadsheet as a fundamental tool for working with data.

1989

SQL Server

In 1989 Microsoft, in partnership with Sybase and Ashton-Tate, released the first version of SQL Server. It grew into one of the major enterprise relational database systems, anchoring data storage for countless Windows-based applications and the services built on top of them.

1990

HyperText Markup Language (HTML)

In 1990 Tim Berners-Lee created HyperText Markup Language at CERN as the document format for his proposed World Wide Web. HTML's simple tags for structuring and linking text made publishing accessible to anyone, and it remains the foundational language of the web.

1990

World Wide Web

Tim Berners-Lee proposed the World Wide Web at CERN in 1989, and by the end of 1990 he had built the first browser, web server, and web pages. The web layered hypertext onto the Internet, creating the platform on which HTTP-based APIs would later flourish.

1991

Linux

In 1991 Finnish student Linus Torvalds released the first version of the Linux kernel and invited others to improve it. Combined with GNU tools, Linux became the dominant open source operating system, powering the servers, containers, and cloud platforms that run most of the world's APIs.

1991

Gopher

In 1991 the University of Minnesota released Gopher, a menu-driven protocol for organizing and retrieving documents across the Internet. Gopher was briefly the chief rival to the web for navigating online information before HTML's inline links and unrestricted licensing won out.

1991

Windows Sockets API

The Windows Sockets API brought the Berkeley sockets networking interface to Microsoft Windows, letting developers write TCP/IP applications for the dominant desktop platform. Winsock standardized Windows networking and enabled the wave of Internet applications and browsers that followed in the 1990s.

1991

Common Object Request Broker Architecture (CORBA)

The Object Management Group published the Common Object Request Broker Architecture in 1991, a standard letting objects written in different languages on different machines invoke one another. CORBA was a major early attempt at language-neutral distributed services, foreshadowing the interoperability goals of web APIs.

1991

HyperText Markup Language (HTML) 1.0

In 1991 Tim Berners-Lee published his first public description of HTML's tag set, defining the small collection of elements from which the earliest web pages were built. Formalizing the markup allowed others to write browsers and pages, spreading the web beyond CERN.

1992

Open Database Connectivity (ODBC)

In 1992 Microsoft released Open Database Connectivity, a standard API that let applications query any compliant database through a common interface and interchangeable drivers. ODBC decoupled applications from specific database vendors, a landmark demonstration of the power of standardized programming interfaces.

1992

Microsoft Access

In 1992 Microsoft released Access, a desktop relational database with visual tools for building tables, queries, forms, and reports. Access made database applications approachable for non-programmers and became a common on-ramp to structured data inside businesses.

1993

Mosaic

In 1993 Marc Andreessen and Eric Bina at NCSA released Mosaic, a free, easy-to-install web browser that displayed images inline with text. Mosaic brought the web to a mass audience and set off the explosive growth that turned the web into a commercial medium.

1993

Common Gateway Interface (CGI)

In 1993 the Common Gateway Interface emerged at NCSA as a standard way for web servers to run external programs and return dynamically generated content. CGI turned the web from static pages into an application platform, an essential step toward web applications and HTTP-based APIs.

1994

PHP

In 1994 Rasmus Lerdorf created PHP as a set of scripts for tracking visits to his personal home page, releasing the code publicly the following year. PHP evolved into one of the most widely deployed server-side languages, powering vast portions of the dynamic web.

1994

Netscape Navigator

In 1994 Netscape Communications, cofounded by Marc Andreessen and Jim Clark, released Netscape Navigator, which quickly became the dominant web browser. Netscape commercialized the web and later introduced technologies such as JavaScript and SSL that remain fundamental to web applications and APIs.

1994

Uniform Resource Locator (URL)

The Uniform Resource Locator was standardized in 1994 in RFC 1738, giving every web resource a single, unambiguous address combining scheme, host, and path. Addressable resources became a core precondition for the web and for REST-style APIs, where URLs identify the things software acts upon.

1994

MySQL

Michael Widenius and David Axmark began developing MySQL in 1994, releasing it publicly the following year. The open source relational database became a pillar of the LAMP stack, backing an enormous share of the dynamic websites and early web APIs of the following decades.

1994

Design Patterns book, by the Gang of Four published; includes axioms like Program to an interface, not an implementation

In 1994 Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides published Design Patterns, cataloging reusable solutions to common object-oriented design problems. Its guidance to program to an interface rather than an implementation became a foundational principle for the loosely coupled, contract-driven thinking that later shaped web API design.

1995

PC Gaming

By 1995 personal computer gaming had become a mainstream driver of consumer hardware, pushing demand for faster processors, graphics cards, and network play. The industry accelerated adoption of home internet connections and multiplayer networking protocols, helping normalize the idea of consumer machines communicating over networks.

1995

GPS Military Operational

In 1995 the United States Global Positioning System reached full operational capability, with a complete constellation of satellites providing worldwide positioning signals. GPS later became a critical data layer for the web, powering the location-aware services and mapping APIs that defined mobile application development.

1995

Apache HTTP Server

The Apache HTTP Server was released in 1995 as an open source web server built from patches to the NCSA httpd codebase. Apache quickly became the most widely deployed web server in the world, demonstrating that open source infrastructure could power the commercial web and serving as the backbone for early web applications and APIs.

1995

Internet Explorer

Microsoft released Internet Explorer in 1995 as part of its push to catch up with the rapidly growing web. Bundled with Windows, the browser brought web access to hundreds of millions of desktop users and became a central battleground in the browser wars that shaped early web standards.

1995

Microsoft Internet Information Services (IIS)

Microsoft shipped Internet Information Services in 1995 as the web server for Windows NT, giving enterprises a supported path to publishing on the web using Microsoft tooling. IIS anchored the Windows side of web application development and later hosted much of the SOAP and ASP.NET web services ecosystem.

1995

JavaScript

Brendan Eich created JavaScript at Netscape in 1995, giving web pages a built-in programming language for interactivity. JavaScript became the universal client-side language of the web and eventually the primary language through which browsers consume APIs, from early dynamic pages to Ajax and modern single-page applications.

1995

HyperText Markup Language (HTML) 2.0

HTML 2.0 was published in 1995 as the first formal specification of the HyperText Markup Language, standardized by the IETF. It codified the core elements of web pages, including forms, which gave the web its first widely used mechanism for submitting user data to servers.

1995

Secure Socket Shell (SSH)

Tatu Ylonen released the Secure Shell protocol in 1995 to provide encrypted remote login and command execution over untrusted networks. SSH replaced insecure protocols like Telnet and became a foundational tool for administering the servers, and later cloud instances, on which web applications and APIs run.

1995

Java

Sun Microsystems released the Java programming language in 1995 with the promise of writing code once and running it anywhere on a virtual machine. Java became a dominant language for enterprise server-side development and hosted much of the web services and API infrastructure built over the following decades.

1995

Open Network Computing (ONC) Remote Procedure Call (RPC)

Sun Microsystems' Open Network Computing Remote Procedure Call was formally published as an IETF standard in 1995, describing how a program could invoke procedures on remote machines. ONC RPC, which underpinned services like NFS, carried the remote procedure call paradigm forward and prefigured the web-based RPC approaches that followed.

1996

HyperText Transfer Protocol (HTTP/1.0)

HTTP/1.0 was documented in 1996 as RFC 1945, formally describing the request and response protocol that browsers and servers had been using to exchange web content. It established the methods, status codes, and headers that remain the mechanical foundation of web APIs today.

1996

Active Server Pages (ASP)

Microsoft introduced Active Server Pages in 1996, allowing developers to generate dynamic web pages by embedding server-side script in HTML. ASP helped move the web from static documents to database-driven applications, expanding the population of developers building interactive services on top of HTTP.

1996

XML

Work on the Extensible Markup Language began at the W3C in 1996, producing a simplified subset of SGML for structuring data on the web. XML became the dominant format for machine-readable data exchange for a decade, underpinning SOAP, RSS, and the first generation of web services.

1996

Google

Larry Page and Sergey Brin began work on Google at Stanford University in 1996, developing the PageRank algorithm to rank web pages by their link structure. Google's search engine made the rapidly expanding web navigable and the company went on to become one of the most influential API providers.

1996

HTTP/1.1

The first HTTP/1.1 specification appeared in 1996 and was published as RFC 2068 in early 1997, adding persistent connections, chunked transfer encoding, caching controls, and virtual hosting. HTTP/1.1 made the protocol efficient enough to carry the commercial web and remained the workhorse transport for web APIs for two decades.

1996

Web Users Reach 36 Million

By 1996 an estimated 36 million people were using the World Wide Web, up from a few million just two years earlier. This explosive growth signaled that the web was becoming a mass medium, attracting the commercial investment that would fund the infrastructure and businesses behind the API economy.

1996

Application Service Provider (ASP)

The application service provider model emerged in the mid-1990s, with vendors hosting software centrally and delivering it to customers over networks for a recurring fee. Though many early ASPs failed, the model established the commercial template that software as a service and API-first companies later perfected.

1997

802.11

The IEEE ratified the original 802.11 wireless networking standard in 1997, defining how devices could exchange data over radio instead of cables. As Wi-Fi, the standard untethered computing from the desk, enabling the laptops, phones, and connected devices that consume APIs from everywhere.

1997

RSS

The ideas behind RSS took shape in 1997 through early web syndication work, including Dave Winer's scriptingNews format and later Netscape's RDF Site Summary. RSS let websites publish machine-readable feeds of their content, giving many developers their first practical experience consuming structured data over HTTP.

1998

XML-RPC

Dave Winer, working with Microsoft, created XML-RPC in 1998 as a simple way to make remote procedure calls by sending XML over HTTP. XML-RPC demonstrated that ordinary web infrastructure could carry program-to-program communication, directly inspiring SOAP and establishing the pattern behind modern web APIs.

1998

IPV6

The IETF published the core IPv6 specification as a draft standard in 1998, expanding the internet address space from roughly four billion addresses to a practically inexhaustible supply. IPv6 was designed to accommodate the coming explosion of connected devices, from servers and phones to the sensors of the internet of things.

1999

MQTT

Andy Stanford-Clark of IBM and Arlen Nipper created MQTT in 1999 as a lightweight publish and subscribe messaging protocol for monitoring an oil pipeline over constrained satellite links. MQTT later became a leading protocol for the internet of things, carrying telemetry from millions of devices to cloud APIs.

2000

REST

Roy Fielding defined Representational State Transfer in his 2000 doctoral dissertation, describing the architectural style underlying the web itself. REST gave developers a principled alternative to heavyweight web services, using plain HTTP methods and resources, and became the dominant design philosophy of the web API era.

2000

Salesforce

Salesforce launched its web-based customer relationship management service in 2000 with an API available from the start, arguing that software should be delivered over the internet rather than installed. Salesforce is widely cited as launching the modern web API era alongside eBay and Amazon.

2000

SOAP

SOAP was published in 2000 as a W3C note defining an XML-based protocol for exchanging structured messages between systems over HTTP and other transports. SOAP anchored the enterprise web services movement, and its perceived complexity later drove many developers toward simpler REST-style APIs.

2000

eBay

eBay launched its API in November 2000, allowing approved partners to programmatically list items and access auction data from its marketplace. The eBay API showed that opening a platform to outside developers could extend a company's reach, making it one of the founding examples of the API economy.

2000

UDDI (Universal Description, Discovery, and Integration)

UDDI was announced in 2000 by IBM, Microsoft, and Ariba as a registry standard for businesses to publish and discover web services. Envisioned as a universal yellow pages for SOAP services, UDDI never achieved broad adoption, but it framed the API discovery problem that the industry still works on today.

2001

Agile Manifesto

In 2001 seventeen software practitioners published the Agile Manifesto, prioritizing working software, customer collaboration, and responsiveness to change over rigid processes and documentation. Agile methods reshaped how software teams work and paired naturally with APIs, which let small teams ship and iterate on independent services.

2001

Protocol Buffers

Google began developing Protocol Buffers around 2001 as a compact, strongly typed binary format for serializing structured data between its internal services. Open sourced in 2008, Protocol Buffers became the foundation of gRPC and a leading alternative to JSON for high-performance service-to-service APIs.

2001

WSDL

The Web Services Description Language was submitted to the W3C in 2001 as an XML format for describing the operations, messages, and endpoints of a web service. WSDL enabled tooling to generate client code automatically and established the machine-readable API definition pattern later carried forward by OpenAPI.

2002

Amazon

Amazon launched Amazon Web Services in 2002 as a set of APIs giving developers programmatic access to its product catalog and affiliate tools. The launch signaled that a major retailer saw its data and functionality as a platform, setting the stage for the cloud computing services Amazon would introduce four years later.

2002

Security Assertion Markup Language (SAML)

OASIS ratified the Security Assertion Markup Language in 2002 as an XML standard for exchanging authentication and authorization data between identity providers and service providers. SAML made single sign-on practical across organizational boundaries and became a cornerstone of enterprise identity federation for web applications.

2003

Delicious

Joshua Schachter launched Delicious in 2003 as a social bookmarking service where users saved and tagged links publicly. Its open API and folksonomy tagging made it a darling of early Web 2.0 developers, who built mashups on its data and popularized tagging as a lightweight approach to organizing information.

2003

Object Relational Mapping (ORM)

Object relational mapping tools such as Hibernate gained mainstream adoption around 2003, letting developers work with database records as native objects in their programming language. ORMs abstracted away SQL for a generation of web developers and accelerated the construction of the database-backed applications that sit behind most APIs.

2003

64-Bit Processor

In 2003 AMD released the Opteron and Athlon 64, bringing 64-bit computing to mainstream x86 servers and desktops while preserving compatibility with existing 32-bit software. The jump past the four-gigabyte memory ceiling enabled the large-memory servers that power modern databases, virtualization, and cloud infrastructure.

2003

AMQP

Work on the Advanced Message Queuing Protocol began in 2003 at JPMorgan Chase, led by John O'Hara, to create an open standard for business messaging. AMQP produced an interoperable wire protocol for message brokers and underpins systems like RabbitMQ, a staple of event-driven and asynchronous API architectures.

2003

Google AdSense

Google launched AdSense in 2003, allowing website owners to earn revenue by displaying contextually targeted ads served automatically by Google. AdSense created a sustainable business model for independent publishers and demonstrated how a platform could distribute value programmatically across millions of third-party websites.

2004

NGINX

Igor Sysoev released NGINX in 2004 as a web server engineered to handle tens of thousands of concurrent connections efficiently. Its event-driven architecture made it a favorite for high-traffic sites and it became ubiquitous as a reverse proxy and load balancer in front of API backends.

2004

Firefox

Mozilla released Firefox 1.0 in 2004, offering a fast, standards-focused open source browser that broke Internet Explorer's near-monopoly. Firefox reinvigorated browser competition and web standards adoption, helping create the healthier client environment on which Ajax applications and browser-based API consumption depended.

2004

Flickr

Flickr launched in 2004 as a photo-sharing service and quickly released an open API that let developers upload, retrieve, and remix photos. Flickr's API-driven approach, alongside its embrace of tagging and sharing, made it an archetype of Web 2.0 and inspired countless mashups.

2004

Web 2.0

The term Web 2.0 was popularized in 2004 through the O'Reilly Media conference of the same name, describing a shift toward the web as a platform of user-generated content, rich interfaces, and data services. APIs were central to the Web 2.0 vision, turning websites into programmable platforms.

2004

Web Services

By 2004 the web services stack of SOAP, WSDL, and the growing family of WS-* specifications had become the enterprise standard for machine-to-machine integration, backed by W3C and OASIS standards work. The complexity of this stack later fueled the backlash that popularized simpler REST and JSON APIs.

2005

JSON-RPC

JSON-RPC emerged in 2005 as a lightweight remote procedure call protocol that encoded requests and responses as JSON rather than XML. It offered a minimal alternative to SOAP and XML-RPC, and its simple request, method, and params structure was later adopted by protocols such as the Model Context Protocol.

2005

ProgrammableWeb

John Musser founded ProgrammableWeb in 2005 as a directory tracking public web APIs and the mashups built on them. Its growing catalog became the standard measure of the API economy's expansion, documenting the climb from a few hundred APIs to more than twenty thousand.

2005

YouTube

YouTube launched in 2005, making it trivial for anyone to upload and share video on the web. Its embeddable player spread video across millions of third-party sites, and its data APIs let developers integrate video search, upload, and playback into their own applications.

2005

AdWords

Google released the AdWords API in 2005, letting advertisers and agencies programmatically manage large advertising campaigns instead of clicking through a web console. It became one of the earliest examples of a company exposing a core revenue-generating business function entirely through an API.

2005

Atom

The Atom Syndication Format was published as RFC 4287 in 2005, providing an IETF-standardized alternative to the fragmented versions of RSS. Its companion, the Atom Publishing Protocol, defined a RESTful way to create and edit web resources, directly influencing early RESTful API design at companies like Google.

2005

OpenID

Brad Fitzpatrick created OpenID in 2005 as a decentralized standard letting users sign in to many websites with a single identity URL. OpenID advanced the idea of federated identity on the consumer web and laid groundwork for the OAuth and OpenID Connect standards that now secure API access.

2006

Amazon S3

Amazon launched the Simple Storage Service in March 2006, offering developers unlimited object storage billed by usage and accessed entirely through an API. S3 was the first major building block of modern cloud computing, proving that core infrastructure could be consumed as a simple web service.

2006

Google Analytics

Google Analytics, built on Google's 2005 acquisition of Urchin, became broadly available in 2006, giving website owners free, detailed measurement of their traffic. It made data-driven decision making standard practice for web publishers and established the analytics category that later gained its own APIs.

2006

Google Maps

Google released the Google Maps API in 2005 and expanded it through 2006, after developers had already reverse-engineered the service to build unauthorized mashups like HousingMaps. It became the most widely used API of the mashup era, proving there was massive developer demand for embeddable web services.

2006

JSON

JSON, the JavaScript Object Notation popularized by Douglas Crockford, was formally documented as RFC 4627 in 2006. Its minimal syntax and native fit with JavaScript made it the preferred data format of the Ajax era, and it steadily displaced XML as the lingua franca of web APIs.

2006

Facebook

Facebook opened registration to the general public in 2006 and launched its Development Platform, giving outside developers API access to social data. Its platform strategy, expanded in 2007, showed how APIs could turn a social network into an ecosystem, while later controversies previewed the governance challenges of open data access.

2006

Amazon EC2

Amazon launched the Elastic Compute Cloud in 2006, letting developers rent virtual servers by the hour through an API call. EC2 removed the capital cost of computing infrastructure, enabling startups to scale on demand and cementing the API as the control plane for modern infrastructure.

2006

Twitter

Twitter launched in 2006 and released its API shortly after, allowing third parties to read and post tweets programmatically. For years most Twitter traffic flowed through its API, and the ecosystem of clients and tools built on it became both a showcase for API platforms and a cautionary tale when access was later restricted.

2006

Mashery

Mashery was founded in 2006 as the first dedicated API management company, offering providers hosted tools for access control, rate limiting, documentation, and analytics. Its emergence signaled that APIs had become products in their own right, requiring their own operational and business infrastructure.

2006

OAuth 1.0 (final draft released December, 2007)

Work on OAuth began in 2006 among developers at Twitter and elsewhere who needed a way to grant applications delegated access without sharing passwords, with the final 1.0 draft released in December 2007. OAuth became the standard authorization framework for APIs, replacing password sharing with scoped, revocable tokens.

2006

Server-Sent Events (SSE)

Server-Sent Events originated in 2006 within the WHATWG's Web Applications specification, defining a simple way for servers to push a continuous stream of updates to browsers over a single HTTP connection. SSE gave web APIs a lightweight streaming option and later became a common transport for streaming AI responses.

2007

Heroku

Heroku was founded in 2007 as a platform that let developers deploy applications by pushing code, with the platform handling servers, scaling, and operations. Heroku defined the platform-as-a-service category and its twelve-factor methodology shaped how a generation built API-backed cloud applications.

2007

iPhone

Apple released the iPhone in 2007, putting a full web browser and always-on internet connection in millions of pockets. The mobile applications that followed were thin clients over web APIs, making APIs the essential backend of the mobile era and multiplying demand for them across every industry.

2007

Twilio

Twilio was founded in 2007 to expose telephony as a set of simple web APIs, letting developers send text messages and place calls with a few lines of code. Twilio proved that an entire business could be an API, becoming the flagship example of the API-as-product model.

2007

Webhook

Jeff Lindsay coined the term webhook in 2007 to describe user-defined HTTP callbacks, where a service pushes data to a consumer's URL when an event occurs. Webhooks inverted the request-response model of APIs, enabling event-driven integrations that remain fundamental to how platforms notify one another.

2007

OData

Microsoft began the work that became the Open Data Protocol in 2007, building on Atom to define standardized conventions for querying and updating data over REST APIs. OData provided uniform URL query syntax and metadata, and was later standardized at OASIS and adopted widely in enterprise products.

2007

3scale API Management

3scale was founded in 2007, offering API providers infrastructure for access keys, rate limits, analytics, and developer portals delivered as a service. Alongside Mashery, 3scale helped establish API management as a distinct market, and its later acquisition by Red Hat marked the category's move into the enterprise mainstream.

2008

App Store (iOS)

Apple opened the App Store in 2008, creating a centralized marketplace where developers could distribute iPhone applications directly to consumers. The resulting explosion of mobile apps, nearly all of them powered by web APIs on the backend, made API development a mainstream requirement for businesses.

2008

GitHub

GitHub launched in 2008, layering social collaboration features on top of the Git version control system. It became the default home for open source software and API definitions, and its own API and pull-request workflow reshaped how developers build, share, and govern code together.

2008

Android

Google released Android in 2008 as an open source mobile operating system, with the HTC Dream as the first handset. Android brought smartphones to billions of users worldwide, vastly expanding the population of mobile applications consuming web APIs and giving Google a platform to rival the iPhone.

2008

Reddit

Reddit, founded in 2005, grew into a major hub of user-driven communities and by 2008 had open sourced its code and offered API access to its content. Its API fed countless third-party clients, bots, and research tools, illustrating both the value and the eventual tensions of open platform data.

2009

NoSQL

The NoSQL movement took its name from a 2009 meetup gathering developers of non-relational databases such as MongoDB, Cassandra, and CouchDB. These systems traded rigid schemas for horizontal scalability and flexible document models, matching the JSON payloads and scale demands of modern API backends.

2009

Foursquare

Foursquare launched in 2009 as a location-based check-in service built for smartphones. Its API exposed a rich database of places and check-ins, making Foursquare a leading example of the location layer of the mobile web and a widely used data source for other applications.

2009

Amazon RDS

Amazon launched the Relational Database Service in 2009, offering managed MySQL databases provisioned and administered through API calls. RDS extended the cloud model from storage and compute to databases, showing that even stateful, operationally demanding infrastructure could be consumed as a service.

2009

Node.js

Ryan Dahl released Node.js in 2009, bringing JavaScript to the server with an event-driven, non-blocking runtime built on Chrome's V8 engine. Node.js made JavaScript a full-stack language and became one of the most popular platforms for building lightweight, high-concurrency API services.

2009

Google Analytics API

Google released the Google Analytics Data Export API in 2009, letting developers pull website traffic data programmatically into their own dashboards and applications. It exemplified a broader shift in which companies exposed their internal reporting and data products through APIs rather than only through web consoles.

2009

Web Application Description Language (WADL)

The Web Application Description Language was submitted to the W3C in 2009 as an XML vocabulary for describing REST-style HTTP APIs, playing the role WSDL played for SOAP. WADL saw limited adoption, but it kept alive the machine-readable API description problem later solved by Swagger and OpenAPI.

2009

WebSub (PubSubHubbub)

Google engineers introduced PubSubHubbub in 2009, a protocol that let publishers push feed updates to subscribers in real time through hubs instead of relying on constant polling. Later standardized by the W3C as WebSub, it advanced the event-driven, publish and subscribe pattern for the open web.

2010

iPad

Apple released the iPad in 2010, establishing the tablet as a mainstream computing category between the phone and the laptop. The iPad expanded the range of screen sizes and contexts that applications had to serve, reinforcing the pattern of a single API backend feeding many client form factors.

2010

SaaS

By 2010 software as a service had become the default delivery model for business applications, with companies like Salesforce, NetSuite, and Google Apps proving the subscription approach at scale. SaaS products depended on APIs for integration with one another, making the API a standard feature of business software.

2010

Nest

Nest Labs was founded in 2010 by former Apple engineers Tony Fadell and Matt Rogers to build the Nest Learning Thermostat. Nest made the connected home tangible for consumers and, with its developer API, became an early flagship of the internet of things built on cloud services.

2010

Instagram

Instagram launched in 2010 as a mobile-first photo-sharing application and reached a million users within months. Built entirely on smartphone clients talking to a web API backend, Instagram exemplified the new generation of API-native companies and was acquired by Facebook less than two years later.

2010

Oracle V Google API Copyright

In 2010 Oracle sued Google, claiming that Google's use of the Java API declarations in Android infringed Oracle's copyrights. The lawsuit raised the question of whether APIs themselves could be copyrighted, threatening the long-standing industry practice of reimplementing interfaces and casting legal uncertainty over software interoperability for the next decade.

2010

Swagger

In 2010 Tony Tam created Swagger at Wordnik, a specification and set of tools for describing REST APIs in a machine-readable format. Swagger enabled interactive documentation, client generation, and design-first workflows, and became the most widely adopted way to describe HTTP APIs, later forming the basis of the OpenAPI Specification.

2010

Docker

Docker, founded in 2010 as dotCloud and released as an open source project in 2013, popularized Linux container technology for packaging and running applications. Containers made it practical to build, ship, and scale the small independent services behind APIs, accelerating the shift toward microservice architectures and API-driven infrastructure.

2010

JSON Schema

JSON Schema emerged around 2010 as a vocabulary for describing and validating the structure of JSON documents. It gave API providers and consumers a shared, machine-readable contract for request and response payloads, and became a foundational building block reused by OpenAPI, AsyncAPI, and countless validation and code-generation tools.

2011

Fitbit

In 2011 Fitbit released a public API providing access to activity, sleep, and health data collected by its wearable devices. It became one of the earliest widely used device APIs, demonstrating how the Internet of Things and the quantified-self movement would depend on web APIs to move personal data between devices and applications.

2011

Apiary + API Blueprint

Apiary, founded in 2011, introduced API Blueprint, a Markdown-based format for describing APIs, alongside hosted tooling for documentation and mock servers. Apiary helped establish the design-first approach to API development, in which teams agree on an API contract and prototype against mocks before writing any server code.

2011

Stripe

Stripe launched publicly in 2011 with a payments API that developers could integrate with a few lines of code. Its clean documentation, predictable design, and developer-first onboarding set a new standard for API developer experience and proved that an API itself could be the entire product of a major company.

2011

Microservices

The term microservices took hold in the early 2010s to describe architectures that decompose applications into small, independently deployable services communicating over APIs. The pattern, pioneered at companies like Netflix and Amazon, made internal APIs a core architectural concern and multiplied the number of APIs enterprises had to design, secure, and govern.

2011

Websockets

The WebSocket protocol was standardized by the IETF as RFC 6455 in 2011, providing full-duplex, persistent connections between browsers and servers over a single TCP connection. WebSockets enabled real-time APIs for chat, collaboration, gaming, and streaming data, moving the web beyond the strict request-and-response model of HTTP.

2011

Kafka

Apache Kafka was open sourced by LinkedIn in 2011 as a distributed log for high-throughput event streaming. Kafka became the backbone of event-driven architectures, and its topics and streams emerged as an asynchronous complement to request-and-response APIs, later described by specifications such as AsyncAPI.

2011

Steve Yegge AWS Rant

In 2011 Google engineer Steve Yegge accidentally published an internal memo describing how a Jeff Bezos mandate had forced all Amazon teams to expose their functionality through service interfaces designed to be externalizable. The rant became the canonical account of the API-first mandate credited with enabling AWS and reshaping enterprise platform strategy.

2011

Fast Healthcare interoperability Resources (FHIR)

HL7 began work on FHIR in 2011 as a modern standard for exchanging healthcare information using web APIs, JSON, and RESTful patterns. FHIR replaced older document-centric health data standards with developer-friendly resources, and was later mandated by United States regulation as the required interface for patient access to electronic health records.

2011

Hypertext Application Language (HAL)

Mike Kelly published Hypertext Application Language in 2011 as a simple convention for embedding links and related resources in JSON and XML API responses. HAL gave the hypermedia principles of REST a practical, minimal format, and was adopted by frameworks and government platforms seeking more discoverable, self-describing APIs.

2011

IFTTT

IFTTT launched in 2011, letting non-programmers connect web services through simple conditional recipes built on top of their APIs. It demonstrated a consumer market for API-powered automation, abstracting authentication and integration details so that ordinary users could wire together social, smart-home, and productivity services.

2011

Zapier

Zapier was founded in 2011 to let businesses connect software-as-a-service applications through automated workflows built on their APIs. By turning thousands of APIs into drag-and-drop building blocks, Zapier established the integration-platform-as-a-service category and made API connectivity a mainstream business capability rather than a developer specialty.

2011

WebRTC

Google open sourced WebRTC in 2011, providing browsers with standard JavaScript APIs for real-time voice, video, and peer-to-peer data communication without plugins. Later standardized by the W3C and IETF, WebRTC embedded telecommunications capabilities directly into the web platform and powered a generation of communications APIs and video applications.

2011

System for Cross-domain Identity Management (SCIM)

Work on SCIM began in 2011 to standardize how identity information is provisioned and managed across cloud services through a REST API and common user schema. Standardized by the IETF, SCIM let enterprises automate account creation and deprovisioning across many SaaS applications, making identity lifecycle management an API-driven process.

2012

President Obama Federal Government API Mandate

In 2012 the Obama administration issued its Digital Government Strategy, directing federal agencies to expose their high-value data and services through web APIs. The mandate made APIs official United States government policy, spawning agency developer programs and pages and legitimizing APIs as public infrastructure rather than purely commercial technology.

2012

OAuth 2.0

The IETF published OAuth 2.0 as RFC 6749 in 2012, defining a framework for delegated authorization that lets users grant applications limited access to their accounts without sharing passwords. Despite debate over its complexity, OAuth 2.0 became the dominant security foundation for web, mobile, and API access control.

2012

Twitter Quadrant Post

In 2012 Twitter published guidance dividing its ecosystem into quadrants and discouraging developers from building client applications that reproduced the core Twitter experience, alongside stricter API rules and token limits. The move alienated the developer community that had helped Twitter grow and became a lasting cautionary tale about platform trust and API governance.

2012

API Strategy & Practice Conference

The API Strategy and Practice conference launched in 2012, organized by 3scale with Kin Lane and Steven Willmott, as a vendor-neutral gathering for the emerging API community. APIStrat brought together providers, developers, and policymakers, and helped formalize API design, management, and business strategy as a distinct professional discipline.

2012

APIDays Conference

APIDays held its first conference in Paris in 2012, founded by Mehdi Medjaoui, and grew into the largest global conference series dedicated to APIs. Its events across Europe, Asia, Australia, and the Americas gave the API economy an ongoing international forum for technology, business, and regulatory discussion.

2012

Payment Services Directive 2 (PSD2)

The European Union revised its payment services rules with PSD2, proposed in 2013 and adopted in 2015, requiring banks to open customer account and payment functionality to licensed third parties through APIs. PSD2 made APIs a regulatory instrument, launching the open banking movement that spread from Europe to markets worldwide.

2013

Slack

Slack launched in 2013 as a workplace messaging platform built from the start around an open API and integration platform. Its bots, webhooks, and app directory made chat a hub for connecting business software, and its developer ecosystem became a widely studied model for platform strategy built on APIs.

2013

Google Reader Shutdown

Google announced in 2013 that it would shut down Google Reader, the dominant RSS reading service, disrupting the ecosystem of applications built on its synchronization API. The shutdown became a touchstone in debates about depending on free platform services and the risks developers assume when building on APIs they do not control.

2013

RESTful API Modeling Language (RAML)

MuleSoft introduced RAML in 2013, a YAML-based language for modeling REST APIs with an emphasis on reusable patterns and design-first workflows. RAML competed with Swagger and API Blueprint during the API description format wars before the industry consolidated around the OpenAPI Specification, to which RAML's backers later contributed.

2013

Plaid

Plaid was founded in 2013 to provide developers with a single API for connecting applications to users' bank accounts, initially by screen-scraping institutions that offered no official interfaces. Plaid became core infrastructure for the fintech industry and a central player in debates over consumer financial data access and open banking in the United States.

2013

QUIC

Google began experimenting with QUIC in 2013, a transport protocol running over UDP that combines encryption with faster connection establishment and multiplexed streams that avoid head-of-line blocking. QUIC was later standardized by the IETF and became the foundation of HTTP/3, improving the performance of web and API traffic globally.

2014

Kubernetes

Google open sourced Kubernetes in 2014, a container orchestration system descended from its internal Borg platform. Kubernetes became the de facto operating layer for cloud-native infrastructure, and its own declarative, extensible API server became a widely imitated model for managing systems entirely through APIs.

2014

James Lewis and Martin Fowler popularize the microservice architectural pattern

In 2014 James Lewis and Martin Fowler published an influential article defining the microservice architectural style as suites of small services, each running independently and communicating through lightweight mechanisms such as HTTP APIs. The article gave the pattern a canonical definition and accelerated enterprise adoption of API-centric service decomposition.

2014

Uber

Uber released its public API in 2014, letting third-party applications request rides and embed transportation into their own experiences. The API illustrated how on-demand, real-world services could be delivered programmatically, and Uber's own architecture of thousands of internal microservices became a reference point for API-driven operations at scale.

2014

Postman

Postman, which began as a Chrome extension for making HTTP requests, was incorporated as a company in 2014 and grew into the most widely used API development platform. Its collections, environments, and testing workflows made API exploration and collaboration accessible to millions of developers, shaping everyday API practice.

2014

Spotify

Spotify launched its Web API in 2014, giving developers access to its music catalog, metadata, playlists, and playback control. The API powered a broad ecosystem of music applications and data projects, and became a common teaching example of a well-documented consumer platform API with OAuth-based user authorization.

2014

Serverless

Amazon introduced AWS Lambda in 2014, letting developers run code in response to events without provisioning servers and paying only for execution time. The serverless model paired naturally with API gateways, making it possible to deploy an entire API as managed functions and shifting operational responsibility to the cloud provider.

2014

ESPN ends its public API program, signaling broader shifts in API strategies

In 2014 ESPN shut down its public developer API less than three years after launching it, restricting access to select partners. The closure, alongside similar retrenchments at Netflix and Twitter, signaled that large media companies were rethinking open API programs in favor of tightly controlled partner distribution.

2014

API Commons

API Commons was launched in 2014 by Kin Lane and Steven Willmott as a place for providers to openly license and share their API definitions and data models. Created amid the Oracle versus Google copyright fight, it promoted the idea that API interfaces should be reusable common infrastructure rather than proprietary property.

2014

OpenID Connect

The OpenID Foundation finalized OpenID Connect in 2014, an identity layer built on top of OAuth 2.0 that lets applications verify who a user is through standardized ID tokens. It became the dominant protocol for single sign-on across web and mobile applications, pairing authentication with OAuth's API authorization.

2014

Azure API Management

Microsoft launched Azure API Management in 2014, building on its acquisition of Apiphany to offer gateway, developer portal, and policy capabilities as a native cloud service. Its arrival, alongside comparable offerings from Amazon and Google, confirmed that API management had become a standard layer of the major cloud platforms.

2014

Netflix Retires Its Public API

Netflix retired its public API in 2014, ending the open developer program that had helped it reach hundreds of devices, in order to focus on internal and partner integrations. The decision showed that APIs could succeed strategically as private infrastructure even as the public program that pioneered them was withdrawn.

2015

OpenAPI

In 2015 SmartBear donated the Swagger specification to a new Linux Foundation project, where it was renamed the OpenAPI Specification. OpenAPI became the industry-standard, vendor-neutral format for describing HTTP APIs, underpinning documentation, code generation, testing, mocking, and governance tooling across the API lifecycle.

2015

gRPC

Google open sourced gRPC in 2015, a high-performance remote procedure call framework using HTTP/2 for transport and Protocol Buffers for strongly typed contracts. gRPC became a popular choice for service-to-service communication inside microservice architectures, offering streaming, code generation, and efficiency that complemented REST at the network edge.

2015

JSON Web Token (JWT)

The IETF standardized JSON Web Tokens as RFC 7519 in 2015, defining a compact, digitally signed format for transmitting claims between parties. JWTs became the ubiquitous credential format for API access tokens and OpenID Connect identity tokens, enabling stateless authentication that services can verify without a central session store.

2015

Apigee IPO

API management provider Apigee went public on Nasdaq in 2015, the first initial public offering from a pure-play API company. The IPO, followed by Google's acquisition of Apigee in 2016, validated API management as a substantial market and set off a wave of consolidation among API vendors.

2015

HTTP/2

The IETF published HTTP/2 as RFC 7540 in 2015, the first major revision of the web's core protocol since 1997. Derived from Google's SPDY experiment, it introduced binary framing, multiplexed streams, and header compression, improving performance for web and API traffic and providing the transport foundation for gRPC.

2015

Amazon Launches AWS API Gateway

Amazon launched API Gateway in 2015, a fully managed service for creating, securing, and scaling APIs, tightly integrated with AWS Lambda. It made API infrastructure a metered cloud utility rather than installed software, and became the front door for the serverless application patterns that followed.

2015

GraphQL

Facebook open sourced GraphQL in 2015, a query language that lets clients request exactly the data they need from a single endpoint against a typed schema. Built originally for Facebook's mobile applications, GraphQL offered an alternative to REST for complex client needs and spawned a large ecosystem of servers, clients, and hosted services.

2015

Let's Encrypt

Let's Encrypt entered public beta in 2015, offering free, automatically issued TLS certificates through the ACME protocol. By removing the cost and friction of HTTPS, it helped push encryption from a minority of web traffic to the default, securing the transport layer beneath virtually all modern API communication.

2015

APIs.json

APIs.json, created by Kin Lane and Steven Willmott and iterated through the mid-2010s, defined a machine-readable index format that providers publish to describe their APIs and supporting operations. Paired with the APIs.io search engine, it proposed a web-style approach to API discovery in which catalogs of APIs could be crawled and indexed.

2015

OpenAPI Initiative Founded

The OpenAPI Initiative was founded in 2015 under the Linux Foundation, with members including Google, Microsoft, IBM, PayPal, and SmartBear, to govern the specification formerly known as Swagger. The neutral, multi-vendor governance structure ended the API description format wars and gave the industry confidence to standardize on OpenAPI.

2015

JSON:API

The JSON API specification reached version 1.0 in 2015, defining detailed conventions for how JSON-based APIs should structure resources, relationships, pagination, and errors. Created by Yehuda Katz and collaborators, it aimed to eliminate repetitive design debates by giving teams a complete, opinionated contract for REST-style APIs.

2015

Kong API Gateway (Open Source)

Mashape open sourced the Kong API gateway in 2015, a lightweight, plugin-based gateway built on NGINX and OpenResty. Kong became one of the most widely deployed open source gateways, and the company later renamed itself Kong Inc., demonstrating that open source infrastructure could anchor a commercial API platform business.

2016

GDPR

The European Union adopted the General Data Protection Regulation in 2016, with enforcement beginning in 2018, establishing strict rules for processing personal data and rights such as access and portability. GDPR reshaped API design and operations, since APIs are the channels through which personal data flows, is exported, and is deleted.

2016

AsyncAPI

The AsyncAPI specification was created by Fran Mendez in 2016 to describe event-driven and message-based APIs in the way OpenAPI describes HTTP APIs. Covering protocols such as Kafka, MQTT, AMQP, and WebSockets, AsyncAPI brought contracts, documentation, and code generation to the asynchronous side of the API landscape.

2016

Amazon Alexa Voice Service

Amazon opened the Alexa Voice Service and Alexa Skills Kit to developers in the mid-2010s, allowing third parties to build voice-driven skills and embed Alexa in their own devices. Alexa established voice as a mainstream API-driven interface, with tens of thousands of skills invoking backend APIs through spoken requests.

2017

OpenBanking UK

Following a 2016 order from the Competition and Markets Authority, the United Kingdom's Open Banking program launched in January 2018, requiring the nine largest banks to expose standardized account and payment APIs. It became the most closely watched national open banking implementation, providing a template for regulated API ecosystems worldwide.

2018

California Consumer Privacy Act (CCPA)

California enacted the California Consumer Privacy Act in 2018, granting residents rights to know, delete, and opt out of the sale of their personal information. As the first comprehensive state privacy law in the United States, it forced companies to build data access and deletion workflows, much of which is delivered through APIs.

2018

HTTP/3

In 2018 the IETF adopted QUIC as the transport for the next version of HTTP and named the protocol HTTP/3, which was published as RFC 9114 in 2022. Running over UDP instead of TCP, HTTP/3 reduced connection setup latency and head-of-line blocking, improving performance for web and API traffic on unreliable networks.

2018

CloudEvents

The Cloud Native Computing Foundation launched CloudEvents in 2018 as a specification for describing event data in a common, portable format. By standardizing event metadata across producers, brokers, and clouds, CloudEvents made event-driven integrations more interoperable and complemented AsyncAPI in formalizing the eventing side of API architecture.

2018

Facebook Cambridge Analytica API Scandal

In 2018 it was revealed that Cambridge Analytica had harvested data on tens of millions of Facebook users, collected years earlier through the Graph API's permissive friend-data permissions. The scandal triggered congressional hearings, a record Federal Trade Commission fine, and industry-wide tightening of platform API access and data governance.

2019

MuleSoft Acquired by Salesforce

Salesforce completed its acquisition of MuleSoft, announced in 2018 for approximately 6.5 billion dollars, the largest purchase of an API and integration company to that point. The deal signaled that enterprise software giants viewed API-led connectivity as strategic infrastructure and accelerated consolidation across the integration market.

2020

COVID Accelerates API Adoption

The COVID-19 pandemic in 2020 forced businesses, schools, and governments to move operations online almost overnight, compressing years of digital transformation into months. APIs carried the surge in e-commerce, telehealth, remote work, vaccine data, and government services, cementing their role as essential infrastructure rather than optional technology.

2020

OpenAI API (GPT-3)

OpenAI released GPT-3 in 2020 exclusively through a commercial API rather than as a downloadable model. Developers could suddenly add state-of-the-art language generation to applications with a single HTTP call, establishing the API as the primary distribution channel for large AI models and launching the modern AI API economy.

2021

Oracle v Google Supreme Court Decision

In April 2021 the United States Supreme Court ruled six to two in Google v. Oracle that Google's copying of the Java API declarations for Android was fair use. The decision ended an eleven-year legal battle and lifted the threat that reimplementing APIs would routinely constitute copyright infringement, preserving established interoperability practices.

2022

Stable Diffusion API

Stability AI released Stable Diffusion in 2022 as an openly available image generation model, alongside hosted APIs from Stability and others. Its open weights let anyone run or serve image generation, spawning a wave of generative image APIs and demonstrating an open source counterweight to proprietary, API-only AI models.

2022

LangChain

LangChain was released in late 2022 as an open source framework for building applications that chain large language models together with external tools, data sources, and APIs. It popularized patterns such as retrieval-augmented generation and tool-using agents, positioning APIs as the hands through which language models act on the world.

2022

ProgrammableWeb Shuts Down

In late 2022 MuleSoft shut down ProgrammableWeb, the directory and news site that had chronicled the API economy since 2005 and cataloged more than twenty thousand APIs. Its closure ended the web's longest-running record of the API industry and left API discovery without a central, neutral public directory.

2023

ChatGPT API

In March 2023 OpenAI released an API for the model behind ChatGPT, priced roughly ninety percent lower than earlier GPT-3.5 access. The dramatic price drop and simple chat-completion interface set off an explosion of AI-powered products, making conversational AI a commodity capability available to any developer through an API.

2023

OpenAI Function Calling

In June 2023 OpenAI added function calling to its chat models, letting developers describe functions in JSON Schema so the model could return structured arguments for invoking them. The feature gave language models a reliable mechanism for driving external APIs and became the template for tool use across the AI industry.

2023

Anthropic Claude API

Anthropic opened access to its Claude models through a commercial API in 2023, emphasizing safety research and large context windows. Claude's arrival established meaningful competition in the frontier model API market and reinforced the pattern of AI capability being consumed as a metered, hosted API rather than shipped software.

2023

OpenAI Assistants API

At its first developer conference in November 2023, OpenAI introduced the Assistants API, providing persistent threads, file-based retrieval, code execution, and tool calling as managed primitives. It marked a shift from raw model completions toward higher-level agent infrastructure delivered through APIs, foreshadowing the agent platforms that followed.

2023

Twitter/X API Pricing Overhaul

In 2023 Twitter, rebranding as X, eliminated its free API tiers and introduced enterprise pricing reaching tens of thousands of dollars per month. The change killed many third-party clients, bots, and academic research projects, and became a stark example of platform risk for developers and researchers dependent on a single API.

2023

Reddit API Pricing Controversy

In 2023 Reddit began charging steep fees for API access that had long been free, forcing popular third-party clients such as Apollo to shut down. Thousands of subreddits went dark in protest, making the dispute a defining public battle over who pays for platform data in the age of AI training.

2024

CFPB 1033 Rule

In October 2024 the Consumer Financial Protection Bureau finalized its rule under Section 1033 of the Dodd-Frank Act, requiring financial institutions to give consumers and authorized third parties access to account data through standardized digital interfaces. The rule effectively mandated open banking APIs in the United States, aligning it with regimes abroad.

2024

Model Context Protocol (MCP)

Anthropic released the Model Context Protocol in November 2024 as an open standard for connecting AI assistants to tools, data sources, and APIs through a common client-server interface. Rapidly adopted across the industry, MCP became the leading answer to how agents discover and invoke capabilities without bespoke integrations for every service.

2024

EU Digital Markets Act Enforcement

The European Union's Digital Markets Act became fully enforceable against designated gatekeepers in March 2024, obligating the largest platforms to provide interoperability, data portability, and third-party access, including messaging interoperability requirements. Enforcement made open interfaces a legal obligation for big tech, extending API mandates from banking into the platform economy.

2025

OpenAPI Arazzo Specification

The OpenAPI Initiative released the Arazzo Specification, first published in 2024 and advanced through 2025, to describe sequences of API calls as machine-readable workflows across one or more API descriptions. Arazzo lets providers document real use cases end to end, supporting testing, documentation, and AI agents that need to execute multi-step operations.

2025

FAPI 2.0

The OpenID Foundation finalized the FAPI 2.0 Security Profile in 2025, a hardened set of OAuth 2.0 and OpenID Connect requirements for high-value APIs in finance and other regulated sectors. FAPI 2.0 simplified its predecessor while strengthening protections, and was adopted by open banking and open data programs around the world.

2025

OpenAPI Overlays Specification

The OpenAPI Initiative published the Overlay Specification, defining a standard way to apply repeatable transformations to OpenAPI documents without editing the source description. Overlays let teams layer on translations, documentation improvements, and governance changes in a maintainable way, supporting workflows where a single API description serves many audiences and pipelines.

2025

AI Agent APIs

By 2025 major AI providers were shipping dedicated agent APIs and SDKs that package models with tool use, memory, computer use, and orchestration, while enterprises exposed their own systems for agent consumption. The shift reframed APIs as interfaces designed for autonomous software consumers, not just human developers, reshaping documentation, discovery, and access control.

2025

Agent-to-Agent (A2A) Protocol

Google announced the Agent2Agent protocol in April 2025, an open standard enabling AI agents from different vendors to discover one another, exchange tasks, and collaborate, with dozens of launch partners and later stewardship under the Linux Foundation. A2A complemented MCP by standardizing communication between agents rather than between agents and tools.

Discovery

Learnings

Guidance

Toolbox

Alignment

API Evangelist LLC

This Page

Open & Ask

Newsletter

Discover APIs

API Timeline

Pre-Historic

Drums Are Used to Communicate

Historic

Pigeons Are Used to Send Messages

1753

Charles Morrison Says Electricity Can Transmit Messages

1753

Electrostatic Telegraph

1770

Music box

1775

Electric Telegraph

1790

Barrel Organ

1801

Loom

1804

Electrochemical Telegraph

1805

Barrel Piano

1816

First Working Telegraph

1822

Charles Babbage takes first steps in the construction of machines that would compute numbers

1822

Steam Calculator

1830

Steam Locomotive

1837

Charles Babbage published a paper describing a mechanical computer that is now known as the Analytical Engine

1839

First Commercial Telegraph (Railway)

1842

Punch Tape Player Pianos

1843

Ada Lovelace first describes what is known as a computer and its software

1844

First Long Distance Telegraph Message

1844

Innocenzo Manzetti Modeled Speaking Telegraph

1846

Punch Tape Telegrams

1846

Printing Telegraph

1847

Paper Roll Traveling Valve Reed Organ

1851

Morse Code

1854

Principes of the Telephone

1860

Panetelegraph

1861

First Speech-Transmitting Telephone

1871

Intent to Invent Sound Telegraph

1876

Bell Patents Telephone

1876

Bell sends "Mr. Watson, come here! I want to see you!"

1877

First Telephone Exchange in Boston

1877

First long-distance telephone line

1880

Scanning Phototelegraph

1887

Multiplex Switchboard

1888