Labor is the political dimension of APIs that the industry most wants to ignore, and I’ve made a point of not letting it go unexamined. Behind every API is human work — the developers who build it, the workers whose tasks it automates, the people whose labor is hidden behind the clean abstraction of an endpoint. And APIs do something specific and consequential to labor: they reduce work to transactions, and transactions can be metered, outsourced, automated, and extracted from in ways that whole jobs cannot. The politics of API labor is about who does the work, who captures the value of that work, and who bears the cost when work gets commoditized into callable functions. This is uncomfortable territory, because the API economy I’ve spent my career evangelizing has a labor underside that the celebratory narratives leave out, and an honest account has to include it.
The reduction of developers to a transaction is the labor dynamic I’ve written about most pointedly, because it implicates the very people building the API economy. I wrote in 2017 about reducing developers to a transaction with APIs, microservices, serverless, DevOps, and the blockchain — the way the architectural trends the industry celebrates also break developer work into small, reusable, commoditized units. When you decompose software into microservices and serverless functions and reusable API calls, you’re also decomposing the work of building it, and decomposed work is easier to outsource, to automate, and to devalue. I wrote about reducing our own hard work to a transaction — the uncomfortable recognition that developers, by building these systems, are contributing to the commoditization of their own labor. The factory-floor metaphor I’ve used for API operations is apt in a darker sense too: the digital API factory floor is a place where work is industrialized, and industrialized work has historically meant labor that’s measured, optimized, and disciplined in ways that shift power toward whoever owns the factory.
The extraction of value from developer communities is the labor exploitation that happens in plain sight, dressed up as community. I wrote a deliberately satirical piece in 2017 about extracting as much value as you can from your API community and giving nothing back — because the pattern is so common it deserved to be named and mocked. Platforms use hackathons, developer events, contests, and community engagement to extract enormous amounts of free labor from developers — code, content, evangelism, bug reports, integrations — while giving little in return and retaining all the ownership and upside. The developers contribute their work to the platform’s ecosystem, the platform captures the value, and when the platform’s interests change, the developers get extracting-as-much-value-then-screwing-them-over treatment. This is labor politics: the platform holds the power, the developers provide the labor, and the relationship is structured to flow value upward. Recognizing the free labor that API communities provide, and how rarely it’s compensated or credited, is part of seeing the labor politics of the API economy clearly.
The gig economy is where API labor politics becomes most visible and most consequential for workers who aren’t developers. APIs are the control infrastructure of the gig economy — the mechanism through which platforms direct, monitor, and discipline a workforce of contractors who have none of the protections of employees. I wrote in 2017 about Uber using its Driver API to paint a bigger picture of its drivers — the API as a surveillance and control mechanism, gathering data on workers to increase the platform’s leverage over them. The Uber API for the sharing economy that I wondered about in 2014 turned out to be exactly this: APIs as the technical means by which gig platforms exert algorithmic control over labor, setting prices, assigning work, monitoring performance, and managing workers through software rather than human management. This is the API as an instrument of labor control, and it’s one of the most politically significant uses of APIs in the entire economy. The worker experiences the API as a boss they can’t argue with, and the platform experiences the worker as a transaction it can optimize.
The hidden human labor behind APIs and AI is the dimension that’s becoming more urgent, not less. Amazon’s Mechanical Turk made it explicit — an API for human labor, where the “function” you call is actually a person doing a task, abstracted behind an endpoint so the human becomes invisible. But the pattern is everywhere: the content moderators, the data labelers, the people whose work trains and supports the AI systems that are presented as autonomous. APIs are very good at hiding the human labor behind a clean abstraction, and that hiding is politically consequential, because invisible labor is easy to underpay, easy to ignore, and easy to deny protections to. The reduction of everything to a transaction, which I’ve written about as a core property of APIs, applies to human labor too — and when human work is reduced to a callable transaction behind an API, the human can be commoditized, surveilled, and devalued in the same way any other resource can. The phrase I used in 2024 — “I see you as just a bunch of daily API calls” — captures the dehumanizing potential of reducing people, their labor, and their attention to metered transactions.
The honest reckoning, which I’ve tried to bring to this throughout my work, is that the API economy has a labor politics that its boosters consistently omit, and that omission is itself political. The celebratory story is about innovation, efficiency, and economic growth. The omitted story is about whose labor produces that value, whose work gets commoditized and devalued, whose jobs get automated, and who captures the gains. APIs are genuinely powerful and genuinely useful, and I believe in them — but they’re also instruments of a particular political economy that concentrates value and power in the hands of platform owners while distributing the labor and the risk to developers, contractors, and the invisible workers behind the abstractions. The right to an API key and algorithmic organizing, which I wrote about in 2014, was an early attempt to think about how workers and developers might build collective power in an API-mediated economy — because if APIs are how work is controlled and value is extracted, then the politics of labor in the API age is partly about whether the people doing the work can organize against the platforms that control them. I don’t have a tidy resolution to offer. What I have is the insistence that the labor question is real, that it’s political, and that an honest account of the API economy has to reckon with the human work behind every clean abstraction and the power dynamics that determine who benefits from it. The API hides the labor. Part of my job has been to keep pointing at the labor the API hides.
References
- Who Is Going To Build The Uber API Platform For The Sharing Economy
- API Evangelist Thoughts On The Right To An API Key And Algorithmic Organizing
- Extracting As Much Value From Your API Developers As You Can Then Screwing Them Over In The End
- Reducing Our Hard Work To A Transaction With APIs And Serverless
- Uber Is Painting A Bigger Picture Of Their Drivers With Driver API Partnerships
- Reducing Developers To A Transaction With APIs, Microservices, Serverless, DevOps, And The Blockchain
- Extract As Much Value As You Can From Your API Community And Give Nothing Back
- What I Mean By APIs Reduce Everything To A Transaction
- I See You As Just A Bunch Of Daily API Calls
- The Digital API Factory Floor
