Stainless in 2025: Building the API platform we always wanted

For many members of the Stainless team, building APIs has been our life’s work.

But in those past lives, we all reinvented the same wheels. We wrote and maintained our API client libraries by hand, and then created generators for them when that didn't scale. We cobbled together open source documentation tools, but ended up writing our own systems from scratch to deliver better UX. We debated decisions on pagination, timestamp formatting, and all the other tiny details that go into making a great API. And unfortunately in 2025, many teams are still re-solving these same problems.

At Stainless, we hope to change that. We're building a toolset for API teams that turns these hard-won lessons into software that any company can use to deliver a world-class API. And as it turns out, we’re building it just in the nick of time. With the rise of powerful LLMs and the crucial role of code generation for AI agents, the need for robust and well-documented APIs has never been greater.

In collaboration with customers building the next generation of foundational APIs, we’ve made significant progress toward our goal of empowering anyone to build amazing APIs. Before we welcome the new year, we wanted to share a few highlights from Stainless over the last twelve months.

Evolving the world's most powerful SDK generator

Stainless’ first product for API developers was our SDK generator. Based on the SDK generator the Stainless team created at Stripe, this tool enables you to create robust, idiomatic API SDKs for a variety of programming languages.

This year, Stainless enhanced our industry-leading SDK generator with support for several new programming languages and environments.

New languages

In 2025, we introduced support for Java, Kotlin, PHP, C#, and Ruby in the SDK generator. Here's an example from our friends at Anthropic, using their new Java SDK.

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

MessageCreateParams params = MessageCreateParams.builder()
    .maxTokens(1024L)
    .addUserMessage("Hello, Claude")
    .model(Model.CLAUDE_SONNET_4_20250514)
    .build();

Message message = client.messages().create(params);

Improved generators for Go and TypeScript

In addition to new programming languages, we improved code generation and shared components for the Go and TypeScript SDK generators as well. The new TypeScript SDK generator uses built-in fetch for HTTP requests, making the TypeScript SDK dependency-free by default.

The code below shows off the new Responses API from OpenAI, using the v2 TypeScript SDK generator. The snippet includes a cameo from custom code in the OpenAI SDK that aggregates text output from the model into a single output_text property at the SDK layer, improving end user DX without impacting the behavior of the underlying REST API.

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.2",
  input: "Write a short bedtime story about a unicorn.",
});

console.log(response.output_text);

Terraform provider

In 2025, Stainless introduced support for Terraform provider generation, allowing Terraform configurations to provision resources with your REST API.

Here's an example resource definition from the Cloudflare Terraform provider:

resource "cloudflare_dns_record" "example_dns_record" {
  zone_id = "023e105f4ecef8ad9ca31a8372d0c353"
  name = "example.com"
  ttl = 3600
  type = "A"
  comment = "Domain verification record"
  content = "198.51.100.4"
  proxied = true
  settings = {
    ipv4_only = true
    ipv6_only = true
  }
  tags = ["owner:dns-team"]
}

Command line interface generator

Stainless now generates CLI applications for your API as well. This gives API users an easily scriptable way to interact with your API in shell scripts and CI environments.

Webhook support

The SDK generator now supports webhooks as configured in your OpenAPI spec, allowing SDK users to get strongly typed objects for incoming webhook events.

Here's an example of unwrapping a webhook event for processing in the OpenAI SDK:

import { headers } from "next/headers";
import OpenAI from "openai";

const client = new OpenAI({
  webhookSecret: process.env.OPENAI_WEBHOOK_SECRET,
});

export async function webhook(request: Request) {
  const headersList = headers();
  const body = await request.text();

  try {
    const event = client.webhooks.unwrap(body, headersList);
    console.log(event);
    return Response.json({ message: "ok" });
  } catch (error) {
    console.error("Invalid webhook signature:", error);
    return new Response("Invalid signature", { status: 400 });
  }
}

You can learn more about the SDK generator in the Stainless docs here!

Stainless Docs Platform

All great API platforms need high-quality documentation. But keeping docs in sync with an API that evolves rapidly can be a major challenge. That’s why we created the Stainless Docs Platform, which keeps API reference and narrative docs in sync with your API. And better still, it’s built using the powerful open source web framework Astro, so you can hack anything and deploy your docs anywhere.

Our friends at Anthropic were among the first adopters of the Docs Platform, and they did an amazing job with it on their new documentation site!

Read more in the announcement blog post here, and sign up for early access here! We’ll have many more exciting announcements about the Docs Platform to share in the new year.

MCP server generation with code execution

In a little over a year, the Model Context Protocol (MCP) standard has exploded in popularity, and emerged as the favored choice for exposing data and functionality to AI agents from Cursor to ChatGPT.

With Stainless, you can generate an MCP server that exposes your API to AI agents in a robust, flexible, and token-efficient way. The Stainless MCP server gives the model detailed information about your API on demand, and can execute integration code created by the model to carry out complex instructions.

A Stainless MCP server already makes your API more reliably usable by AI agents, and we're just getting started. Expect more developments in 2026 to make your API more useful in AI applications.

You can learn more about Stainless MCP server generation (and code execution) in the docs.

Advanced DX features for API teams

In addition to these headline features, we’ve also been hard at work anticipating the needs of API platform teams building non-trivial interfaces at scale. Here are a few updates we’re particularly proud of:

• Spec transforms that enable API teams to massage generated OpenAPI specs so that you can generate clean SDKs

• Preview builds that make it easy for API contributors to see how their changes will affect SDKs generated from their API spec

• An Autoguesser that suggests and implements fixes to your API specification and Stainless config file

You can check out these and other platform updates in the Stainless changelog.

New friends with the same mission

When you’re obsessed with designing and building APIs, it’s comforting to know you're not the only one. In 2025, Stainless grew from 13 full-time team members to 49 people who wake up every day excited to make programming better for everyone.

If you love APIs as much as we do, you should join us!

Looking ahead to 2026

In 2026, every company must become an API company.

Soon, most knowledge workers will be using a general purpose AI agent like ChatGPT, Claude, or Gemini to get their work done every day. This means they will be using your custom software UIs less and less over time. Your software will still provide essential services, but to work efficiently with AI agents, it will need a robust programmable interface. A day is fast approaching where if AI agents can’t successfully integrate with your services, they might as well not exist.

Stainless is here to assist, both by helping you provide great APIs and language SDKs, and providing the docs content and MCP server layer required to help models integrate. Getting your platform ready for AI agents is a big job, but you've got this! Reach out to us if you could use a hand in planning and brainstorming.

While we're proud of what we achieved in 2025 along with our customers, there's so much more to build. In 2026, we'll be bringing more of our new products to full GA readiness, and introducing brand new tools that API teams need to operate at scale. Stay tuned for updates from Stainless throughout the year on X and LinkedIn.

Thank you so much for building with us in 2025. We’re beyond excited to work alongside you to create world-class APIs in 2026!