APIs have expanded dramatically since Roy Fielding published his dissertation, which introduced REST in 2000. One look at the number of public Postman Collections alone should be enough to tell you that. Public Postman collections expanded by more than 10 million in a single year, growing from 25 million in 2023 to 35 million in 2024. With so many APIs being created and used for all manner of different purposes, it’s no surprise that there has been an explosion in API architectural styles.

For the longest time, prevailing wisdom suggested that all HTTP-based APIs should be RESTful. REST remains the most popular architectural style for APIs, with 92% of organizations saying they use REST, according to a June 2025 study conducted by Enterprise Strategy Group.

However, numerous architectures have arisen as a result of shifting demands for real-time data. 70% of developers are using GraphQL, 38% use SOAP, 44% use RPC and gRPC, and 41% prefer websockets. Model Context Protocol (MCP) has been exploding in popularity in 2025, but it’s still too new to reliably say how many developers are using MCP.

To help make sense of the different API architectural trends, we’ve put together a guide to the top API architectural styles of 2025.

API Architectural Styles of 2025: A Quick Glance

REST

Representational State Transfer (REST) is still the most common API architectural style in 2025. Built using HTTP, REST uses standard GET, POST, PUT, and DELETE commands to make changes to resource-based endpoints. Its clarity, combined with its familiarity, makes REST particularly popular among developers. It also means that many frameworks, third-party tools, and resources, like Express.js, Flask, and Spring Boot, offer support for REST right out of the box. Its stateless nature and established practices for versioning, caching, and error handling make REST an excellent choice for web applications and mobile backend services.

For a real-world example of a REST API, consider the GitHub API, which allows developers to access most of GitHub’s core functionality using standard HTTP requests. The OpenWeatherMap API is another popular and well-known REST API that lets users query the API for historical weather data for different locations.

GraphQL

GraphQL gets increasingly popular with each passing year, due to its granular control of data. GraphQL’s strongly-typed schema allows users unprecedented control over what data is sent and received. This makes it ideal for enhancing performance and API security. It also helps keep costs down, as it prevents unnecessary data from being transferred.

GraphQL is also good for developers drawing data from multiple sources, as it flattens all sources into a single query point. This is part of what makes GraphQL so good for responsive web design. Developers looking to create single-page applications and mobile apps should definitely consider GraphQL when choosing an API architectural style.

For an example of a GraphQL API, consider the Yelp GraphQL API. It’s a good representation of GraphQL’s granular control of data.

Event-Driven Architecture (EDA)

Event-driven architecture (EDA) has been gaining prominence due to the spread of asynchronous and event-based communication. Rather than querying individual endpoints, EDA provides endpoints like order.created or file.uploaded that services can subscribe to. EDA is particularly popular in microservices, IoT environments, or any scenario that calls for loosely-coupled, reactive systems. It’s also especially good for circumstances that require optimal performance, as an event occurs virtually instantaneously when EDA is invoked.

For example, Apache Kafka, a distributed event streaming platform, allows producers to build a real-time data pipeline by publishing, storing, and consuming events asynchronously using Topics. API consumers can subscribe to topics and then consume events asynchronously. Outside of Kafka, other examples of popular EDAs include Amazon EventBridge, Azure Event Grid, Google Cloud Pub/Sub, and RabbitMQ.

SOAP

Simple Object Access Protocol (SOAP) is mostly a legacy architectural style at this point, but it’s still used by enterprise systems that require rigid contracts or enhanced security. As one of the oldest API architectural styles, SOAP uses XML instead of REST, making it more secure due to XML’s particular standards. SOAP also provides native support for advanced security layers like WS-Security, allowing features like message encryption, digital signatures, and authentication. This makes SOAP a popular choice for systems that call for robust security, like health, finance, or telecommunications.

To see a SOAP API in action, check out WebServiceX Currency Converter. To query that endpoint, you’ll need to send an HTTP request using a tool like Postman. You’ll need to add two headers: ContentType and SOAPAction — with the values text/xml; charset=utf-8 and "http://www.webserviceX.NET/ConversionRate", respectively. Then you can send the following request in the body:

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <ConversionRate xmlns="http://www.webserviceX.NET/">
      <FromCurrency>USD</FromCurrency>
      <ToCurrency>EUR</ToCurrency>
    </ConversionRate>
  </soap:Body>
</soap:Envelope>

As you can see, SOAP is bulky to work with, but it’s very secure. Given its enduring use, it’s worth knowing how to work with it.

Webhooks

Webhooks are still used heavily in 2025 for reasons similar to EDA’s popularity. Like EDA, webhooks deliver a payload whenever an event occurs, like user.subscribe or order.paid, instead of when a resource is queried. This makes webhooks an ideal API architecture for CI/CD systems or for integrating SaaS solutions. Webhooks are also popular for public applications that need to service clients without central coordination. They’re also relatively simple to secure using tokens or an HMAC signature.

Webhooks aren’t ideal for every situation, though. Resources are generally only sent once, so you’ll need to manually implement some form of replay logic if you’re planning on using webhooks.

For an example of a webhook API, consider Stripe’s Webhook API. It lets you create an endpoint for your webhook, which then sends an HTTP POST request anytime an event occurs.

gRPC

gRPC, or Google Remote Procedure Call, remains popular and widely used in 2025 thanks to its efficiency, making it ideal for microservice-to-microservice communication and backend systems where performance is key. Built using HTTP/2 and Protocol Buffers, gRPC delivers compact payloads, strong typing, and bidirectional RPC. gRPC’s performance makes it a good choice for situations where performance matters, like financial trading, real-time gaming, distributed databases, and telemetry-heavy pipelines that rely on millisecond latency and compact payloads. It’s also suitable for service meshes like Istio and Linkerd.

For a real-world example of gRPC, check out Google’s gRPC repository to see how gRPC is implemented in most popular programming languages.

MCP

Model Context Protocol (MCP) is the breakout star of API architectural styles in 2025. It’s an architectural style designed for connecting AI agents and their large language models (LLMs) to external resources. Detailed descriptions in the MCP schema allow LLMs and AI ecosystems to know precisely what an MCP server does, allowing them to pick the right tool for a specific task. It also allows users to send assets like user prompts directly to AI tools in a query. MCP is an excellent choice for AI-first teams, platform engineers working with LLMs, and developers building AI workflows.

For a good real-world example of an MCP server, consider the Slack MCP Server. Once it’s installed, it allows AI coding assistants like Claude to use virtually all of Slack’s functionality.

Final Thoughts On the Top API Architectural Styles of 2025

The roles that APIs fill in the digital landscape have greatly diversified in the last 20 years. This means that API architectural styles have also diversified as a result. To review:

• REST remains the most popular API architectural style in 2025, due to its simplicity and widespread usage. GraphQL also remains a popular choice, as it gives users fine-tuned control over how they access and consume data.
• EDA and webhooks remain an excellent choice for real-time, event-driven architecture like microservices, web apps, and IoT.
• gRPC is a good pick for situations where performance is of the utmost importance, like financial trading, real-time gaming, telemetry, or IoT.
• SOAP is still a good choice for legacy institutions and situations that require advanced security.
• MCP is the best API architectural style of 2025 for anyone working with agentic AI, AI-first design, and platform engineers.