What tools are available for API composition?

• Your question is a bit ambiguous — "API composition" could mean the microservices architectural pattern (joining data from multiple services in a query), or it could mean general tools for building/composing APIs together. I'll cover both, but the microservices pattern is likely what you're after given our conversation's context (federation, stitching, gateways).

API Composition as a microservices pattern

• This is a formal pattern name: when you've split a system into microservices with a database-per-service, you often need to answer a query that spans multiple services' data. The API Composer pattern solves this by invoking each service that owns relevant data and performing an in-memory join of the results, rather than querying across service boundaries directly.

Tools/approaches that implement this pattern:

• GraphQL Federation (Apollo Router, Hive Gateway) — the modern default for API composition; a router queries multiple subgraphs and joins results via entity resolution, exactly matching the composer pattern but standardized with a schema

• GraphQL schema stitching — a lighter-weight, more manual version of the same idea (covered in our earlier conversation)

• An API Gateway itself often performs composition — many gateways (Kong, KrakenD, Tyk) support aggregating multiple backend calls into a single client-facing response

• KrakenD specifically is built around this — it's a stateless, declarative gateway designed to compose multiple backend calls into a single response, which is essentially the API Composer pattern implemented at the gateway layer

• Custom composition services — a dedicated backend-for-frontend (BFF) service that calls several downstream services and joins results in application code, without any GraphQL or gateway abstraction at all

• A caveat from the pattern's own documentation: composition can produce inefficient in-memory joins over large datasets — it works well for moderate result sets, but isn't a substitute for CQRS-style materialized read models when you're joining large amounts of data frequently.

If you meant general API development/composition tooling instead

• Design/documentation: SwaggerHub, Stoplight, Redocly — OpenAPI-centric tools for designing and documenting APIs before implementation
• Testing/composition clients: Postman, Apidog, Bruno (Git-native, stores collections as plain text), Insomnia (notably preferred by GraphQL-heavy teams), Hoppscotch, Thunder Client (VS Code-native)
• Low-code composition/integration platforms: tools like Boomi, Integrate.io, and MuleSoft let you visually compose multiple APIs into new workflows or endpoints without hand-writing the aggregation logic
• AI-driven documentation from live traffic: newer tools like Levo.ai generate accurate specs directly from production traffic via instrumentation, rather than relying on manually maintained docs — useful when you're composing APIs you don't fully control or whose docs have drifted

If you meant the architectural pattern, GraphQL Federation is the strongest current answer for anything beyond a handful of services; if you meant tooling for building and testing composed APIs day-to-day, Postman/Apidog/Bruno plus SwaggerHub covers most of that. Let me know which you're after and I can go deeper.