
Overview
Apollo GraphOS is the only platform to manage, operate, and evolve the supergraph - a modular layer in the app development stack that unifies existing APIs, data, and services into a single graph.
With GraphOS, app developers can access any service they need with a single GraphQL query. On the backend, teams can continue to work independently by connect existing services to the supergraph with modules called subgraphs, avoiding the bottlenecks caused by monolithic API architectures.
The core capabilities of GraphOS include:
- Modular graph development
Monoliths cause bottlenecks that slow down app development at every scale. With GraphOS, you build your graph on a modular, scalable architecture with subgraphs that link to each other. Subgraphs can be written in over 20 different languages and frameworks that support Apollo Federation.
- Fast, unified query execution
GraphOS links your subgraphs together into the supergraph with a blazing-fast, cloud-native runtime. Access all underlying capabilities with a single GraphQL query and get automatic support for advanced GraphQL features like @defer.
- Safe and rapid graph evolution
Modern apps change by the hour, and your API architecture needs to do the same. GraphOS gives you the tools to develop schemas collaboratively with a single source of truth, deliver changes safely with graph CI/CD, and improve performance with field and operation-level observability.
- Enterprise-class data security
Manage schema variants that align with environments like development, staging, and production. Create advanced variant types that restrict user access and filter out certain fields.
Apollo GraphOS enables leading companies such as PayPal, Netflix, Zillow, Square, and Priceline to deliver new experiences to market at 4x velocity. Read more customer stories: https://www.apollographql.com/customers
For custom pricing or a private contract, please contact SalesInquiries@apollographql.com , for a private offer.
Highlights
- One query, many subgraphs. The query planner and execution engine in GraphOS enable you to gather data from multiple linked subgraphs with a single query, delivering on the true promise of GraphQL.
- Advanced GraphQL features built-in. GraphOS supports the latest GraphQL features within the supergraph layer. Use directives like @defer to optimize your app performance even if your subgraph server doesn't support it natively.
- Ultra-fast and distributed. GraphOS couples the flexibility and distribution of the cloud with all of the speed, power, and advanced capabilities of Apollo Router - our supergraph runtime binary written in Rust.
Details
Features and programs
Buyer guide

Financing for AWS Marketplace purchases
Pricing
Dimensions summary
Top-of-mind questions for buyers
Vendor refund policy
Apollo's terms of service and refund policy https://www.apollographql.com/Apollo-Terms-of-Service.pdf
How can we make this page better?
Legal
Vendor terms and conditions
Content disclaimer
Delivery details
Software as a Service (SaaS)
SaaS delivers cloud-based software applications directly to customers over the internet. You can access these applications through a subscription model. You will pay recurring monthly usage fees through your AWS bill, while AWS handles deployment and infrastructure management, ensuring scalability, reliability, and seamless integration with other AWS services.
Resources
Vendor resources
Support
Vendor support
Work with Apollo experts to design and build your GraphQL API - schema design, integration with existing systems, best practices, developer workflows, and more. Apollo's GraphQL Experts
AWS infrastructure support
AWS Support is a one-on-one, fast-response support channel that is staffed 24x7x365 with experienced and technical support engineers. The service helps customers of all sizes and technical abilities to successfully utilize the products and features provided by Amazon Web Services.


FedRAMP
GDPR
HIPAA
ISO/IEC 27001
PCI DSS
SOC 2 Type 2
Standard contract
Customer reviews
Query optimization has reduced traffic and now speeds up real-time work for our team
What is our primary use case?
My main use case for Apollo GraphOS was splitting queries so that we didn’t pull in all the data we didn’t need, and instead broke it down into smaller, detailed queries. We also used GraphQL Subscriptions to support connections and receive data in real time.
Apollo GraphOS helped me organize working with queries and supported real-time data retrieval, but it’s hard to say it was more convenient because there was more work on the graphics and DevOps side.
How has it helped my organization?
Apollo GraphOS positively impacted my organization by making work much easier and more efficient than REST API after we immersed ourselves in it, which increased our pace and made the team happier.
I can speak for myself regarding the work speed increase. A module might initially be implemented over a two-week sprint, but once we got used to it, I started implementing it within a few hours, thanks to automation.
What is most valuable?
The best features of Apollo GraphOS include the ability to address a single router, while GraphQL itself already handles things with the microservices. I also particularly appreciate the charts and other functionality.
Apollo GraphOS simplifies my work compared to other approaches because I don’t need to write a new microservice every time. Everything is standardized, which allows me to create a single process and then reuse it in other places and teams.
What needs improvement?
In my opinion, Apollo GraphOS could be improved by making it easier for a person to get started with some simplifications or automations that would help someone understand it faster and handle some of the routine work for them.
I chose a nine specifically because the difficulty of getting started prevents me from giving it a ten.
For how long have I used the solution?
I last used Apollo GraphOS about two years ago, and I probably started using it about five years ago.
What do I think about the stability of the solution?
I consider Apollo GraphOS stable, with no outages or problems except for occasional difficulties with installing schemas and migrations.
What do I think about the scalability of the solution?
Apollo GraphOS scales very easily for my tasks if you know how to do it.
How are customer service and support?
I have not contacted Apollo GraphOS's support service because there were no problems, and the documentation was sufficient for resolving any issues.
Which solution did I use previously and why did I switch?
Before using Apollo GraphOS, we were on REST API. The switch helped us reduce traffic consumption and requests, which sped up our subsequent work once we fully switched to Apollo.
What's my experience with pricing, setup cost, and licensing?
My experience with pricing and licensing is that my part didn’t require a license and was completely free, and I can’t speak for what happens at the organizational level.
Which other solutions did I evaluate?
We did not evaluate other options before choosing Apollo GraphOS because there was a recommendation to install it specifically, which we followed and were happy with.
What other advice do I have?
I would rate Apollo GraphOS a nine overall. It’s almost a ten, but there are of course some small drawbacks.
I didn’t handle accuracy and reliability aspects, but everyone was satisfied, and there were no problems.
My advice for those considering implementing Apollo GraphOS is to switch with the whole team to avoid unnecessary maintenance of the REST API.
Shared schema governance has unified our microservices and now simplifies change decisions
What is our primary use case?
My main use case for Apollo GraphOS is to manage our supergraph.
Apollo GraphOS helps my team manage and coordinate changes across that supergraph by allowing us to understand what our schema looks like today and how to best build off it. We use it to understand how our schema and services are being used, including which fields are being used and which are not. It also gives us insight into the ways we can update our services safely.
How has it helped my organization?
Apollo GraphOS has positively impacted our organization by allowing us to migrate from a disarrayed microservice system to a Federation, giving us the ability to know exactly how to reference services and objects. Previously, we had an item object that was created four or five times with different naming conventions, different fields, and different use cases, which became cumbersome to manage and made it difficult to know when to use what field. With the Federation, we were able to define objects once and reuse them across our graph.
The specific outcomes we have seen from that shared object model include the ability to reuse our services and objects in more ways, allowing us to build in one spot and reuse in many ways to save labor and maintenance costs, which has been the main speed up.
What is most valuable?
The best features Apollo GraphOS offers include the ability to see and gain insights on what fields are being used, which is the most impactful feature for our company.
Apollo GraphOS has changed the way my team decides which schema fields or services to update by giving us confidence to know if a field is actually being used. It also helps us understand how important fields are, based on whether users or consumers of our graph actually care about those fields or that data.
Regarding Apollo GraphOS's AI capabilities, I think its governance and security are really good because we have the ability to control which consumers or clients have access to not only operations, but also objects and fields. We have really liked our experience managing the security in the graph.
What needs improvement?
Apollo GraphOS can be improved, as I think the enum management is frustrating and has caused us problems because we have to have uniform or global enum agreement.
We use DGS under the hood with Java from Netflix, and we wish there were better ways to manage enums in the supergraph.
For how long have I used the solution?
I have been using Apollo GraphOS for six years.
What do I think about the stability of the solution?
Apollo GraphOS is stable.
What do I think about the scalability of the solution?
The scalability of Apollo GraphOS is fine.
How are customer service and support?
The customer support from Apollo GraphOS is fine.
I would rate the customer support a seven on a scale of one to 10, as we have not had much experience with them.
Which solution did I use previously and why did I switch?
We previously used Apollo GraphOS and switched because the cost was getting too large.
What was our ROI?
I think the energy and resources have been used better. While it is hard to put numbers to it, we are using the open source version and managing our own, and there has been some maintenance cost. However, for every one hour of maintenance we put in, we get five hours of speed up in development elsewhere.
What's my experience with pricing, setup cost, and licensing?
My experience with pricing, setup cost, and licensing was that it was more expensive than we anticipated, and we have recently moved to use open source HiveOS.
Which other solutions did I evaluate?
We did evaluate other options before choosing Apollo GraphOS, including WunderGraph and their integrations, but we ultimately chose Apollo GraphOS.
What other advice do I have?
I would rate Apollo GraphOS an eight on a scale of one to 10.
I feel it has been a useful tool, clean and easy to use, and it has added value quickly to our company.
Apollo GraphOS is deployed in our organization in both a public and private capacity, and we have two supergraphs.
I would advise others looking into using Apollo GraphOS that it is a solid product. I would look at Apollo GraphOS, WunderGraph, and HiveOS. If you are a large enterprise and money is not an issue, I feel Apollo GraphOS is probably the best fit, while WunderGraph and HiveOS are also doing good things.
Which deployment model are you using for this solution?
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Federated teams have shipped independently and have achieved safe, observable schema changes
What is our primary use case?
Before Apollo GraphOS, we struggled with manual composition, breaking changes in production, no visibility into client usage, and self-hosting the gateway. Since moving to Apollo GraphOS, the big wins I have seen are schema checks and contracts, which let us catch breaking changes in continuous integration now, and the router and observability, which let us finally see which clients use which fields and our P95 latency. We also have federated composition that just works, and no more merge conflicts.
Here is a specific example of how I use Apollo GraphOS in my day-to-day work, in which a team almost broke checkout. At 9:30 AM, the payments team opened a PR to rename order.total to order.totalAmount in their subgraph. At 9:31 AM, the Apollo GraphOS schema check failed in continuous integration. Instead of finding out in production, the check commented right on the PR breaking feed. By 9:35 AM, it was fixed before merge. We saw in Apollo GraphOS Studio that the web checkout had zero downtime, and we shipped the new field, migrating the clients over two weeks while watching the usage metrics in Apollo GraphOS.
Our main use case for moving to Apollo GraphOS in the first place is a federated supergraph for more than 10 teams. Before Apollo GraphOS, we managed composition and the gateway ourselves; every schema publish was a Slack thread and a manual check. Now, Apollo GraphOS is our source of truth, the router pulls the supergraph, composition happens in the cloud, and every subgraph owner can publish independently. The process changed from 'don't break the graph' to 'ship wherever.'
How has it helped my organization?
Apollo GraphOS has been a big net positive for my organization, mainly because it turned our GraphQL from something we had to operate into something we just use. The three biggest impacts are that teams can ship independently without fear of breaking the graph, we finally have client-aware observability, and we shifted to less OPS and more platform. The bottom line is faster shipping, zero breaking changes in production since we adopted it, and real data to safely deprecate fields.
What is most valuable?
The best features Apollo GraphOS offers include Federation Subgraph, Schema Registry, Schema Checks, Usage Insights, Observability, Apollo Explorer, Studio, Router performance features, Apollo Connectors for REST, and a new AI plus OPS layer.
Schema Registry and Schema Checks have helped my team, and Usage Insights and Observability make a significant difference. Before Apollo GraphOS, we had zero visibility. If a subgraph was slow, we didn't know who was calling it or why. With Apollo GraphOS Usage Insights, two things changed: safe deprecation, in which we could see that field X was still used by 15% of traffic from the iOS app, and performance debugging. We encountered a P95 spike to 1.8 seconds, and in Apollo GraphOS traces, we saw that one query from web checkout was calling a subgraph 800 times. GraphQL transformed from a black box into precise knowledge about which client, which version, and which field was costing us.
Governance and security are key focuses for us regarding Apollo GraphOS's AI capabilities. The AI capabilities are actually why we recently renewed and upgraded. We started using the Apollo MCP server, which is simple. Instead of letting our LLM agents hit 20 different REST APIs and subgraphs directly and hallucinate fields, we expose our supergraph as a set of governed MCP tools. In Apollo GraphOS, we curated 15 approved operations, such as getting customer orders or searching products, which are the only tools the LLM can call, so we do not expose our entire 4,000 field schema to it. That is huge for governance. For security, we chose Apollo GraphOS over self-hosting because it is SOC 2 Type 2 compliant, we have SSO with Okta SAML, and we have role-based access with four roles. Viewers can only see metrics but cannot publish. The router runs in our VPC, so the data never leaves, and for connectors, the API keys are in Apollo GraphOS secret manager, not in code, giving us security while still ensuring cloud governance.
The accuracy and reliability of Apollo GraphOS's AI output are very good, but not because the AI itself is magical; it is due to governance. Before using the MCP server, our LLM was guessing fields and hallucinating, with maybe 30% of the queries failing because it invented a field that didn't exist. With Apollo GraphOS, we only expose curated, approved operations via the MCP server. We cut down from 4,000 fields to 15 approved tools. Regarding reliability, it has been very reliable; the router is deterministic, ensuring the same output and query plan. The AI doesn't generate GraphQL; it simply picks an approved operation and fills in arguments, leading to high accuracy, around 95%, I think.
What needs improvement?
To improve Apollo GraphOS, I suggest focusing on specific outcomes, reducing incidents, and enhancing performance. If I had to pick one thing to improve, I would pick two small things: first, the local development experience can be a bit heavy, and second, the documentation for new features such as connectors and the MCP server is still catching up.
Regarding needed improvements, I want to add two top insights that real users mentioned: local dev and debugging, router cold start with more than 10 subgraphs, pricing and observability retention, documentation for new features, and small UX improvements in Studio or Explorer.
For how long have I used the solution?
I have been using Apollo GraphOS for over five years.
What do I think about the stability of the solution?
Apollo GraphOS is stable; we had been using a self-hosted Apollo gateway on Node, and managing composition ourselves was painful. We didn't have any managed schema checks, so breaking changes could slip into production. Therefore, I can confidently say it is stable.
What do I think about the scalability of the solution?
Scalability was a significant reason we moved from the Node gateway to Apollo GraphOS, which handles scalability on two sides. On the data plane, the router is Rust-based, which is more efficient than the old Node gateway. On the control plane, Studio and managed federation handle everything for us as we add more subgraphs. Consequently, we haven't hit a limit yet, and adding a new subgraph doesn't impact the existing ones.
How are customer service and support?
We didn't have a deep formal bake-off for customer support since we were already using Apollo Federation and Apollo Server. Our evaluation revolved around Apollo GraphOS versus staying self-hosted on the open-source gateway and building our own registry and checks in-house. Although we looked at other options briefly, we selected Apollo GraphOS because we didn't want to maintain our own federated tooling and desired managed composition via uplink, schema checks included, and Studio's observability ready out of the box. Support has been stable for us; we handle it via Slack and the support portal or account team, and the response time has been really quick, usually within a day for non-urgent matters. The documentation and Apollo community have also been helpful for Rover and router setup.
I would rate customer support an 8 out of 10. We get support via Slack, and the response time is usually within a few hours for urgent requests. They have helped us with issues related to router upgrades, schema check configurations, and federation directives. The documentation is solid too. The reason I don't give it a 10 is that they take some time; while support is knowledgeable when we reach them, the community or Discord documentation has been more helpful for quick questions. Since the product itself is stable, we don't need support all the time.
Which solution did I use previously and why did I switch?
I previously used a different solution before Apollo GraphOS; we had REST microservices with a cluster of BFFs. The front end had to call five APIs, and we switched to Apollo GraphOS to achieve a single supergraph, allowing teams to own their domains, so the frontend now makes just one query.
What was our ROI?
I have seen a return on investment with Apollo GraphOS, mainly regarding engineering time. Before, we managed composition ourselves; now schema checks block breaking changes before production, allowing eight teams to deploy independently, resulting in fewer incidents and less coordination time.
Which other solutions did I evaluate?
Before choosing Apollo GraphOS, I evaluated a couple of options. We considered staying on self-hosted Apollo Gateway with our custom checks and briefly looked at building a schema registry in-house. We also examined other gateways, such as WonderGraph and Azura, at a high level. Ultimately, we chose Apollo GraphOS because we were already deep into Apollo client and Federation V2, making Apollo GraphOS a good fit for managed composition via uplink, schema checks in-situ, and client-aware observability with operation insights ready out of the box, and we didn't want to maintain the infrastructure.
What other advice do I have?
On a scale of 1 to 10, I would rate Apollo GraphOS as a 9 out of 10. It solved our biggest problems: federated development at scale, zero breaking changes in production thanks to schema checks, and real client-aware observability. Previously we managed the gateway ourselves, which was painful. Now, teams ship independently. The one point off is primarily the local dev experience and docs for newer features such as connectors and MCP.
I chose 9 out of 10 specifically because it has been excellent for the core job. We bought Apollo GraphOS for federated supergraph, schema checks, and observability, aspects that I would rate a 10 out of 10. It has eliminated breaking changes in production and enabled eight teams to ship independently, which was our main goal. The reason it is not a 10 is the maturity of some newer areas; specifically, the local development with many subgraphs can be heavy, and cold starts and composition errors aren't always clear for new developers. Additionally, observability retention and pricing for longer trace history could be more flexible, hence nine is honest. Nothing is perfect at 10, and for our daily use, it is as close to perfect as you get.
Apollo GraphOS is deployed in our organization through a hybrid model, where the control plane, which includes Apollo GraphOS Studio, schema registry, composition, schema checks, operation insights, and traces, is all in the public cloud managed by Apollo. We didn't want to manage that ourselves, so it is in the Apollo cloud. However, the data plane, the actual Apollo GraphOS router that serves traffic, we self-host in our private cloud. We run it in AWS EKS within our own VPC, giving us the best of both worlds.
I recommend looking into Apollo GraphOS. For us, the biggest value is not having to maintain our own registry, with managed composition via uplink, schema checks that block breaking changes in PRs, and having Studio's client-aware observability and operation insights all in one place. Transitioning from the Node gateway to the Rust router also improved performance. It is less useful if you only have a single monolithic GraphQL API or one or two developers. The power comes when you have multiple subgraphs and want teams to deploy independently with contracts and safe schema changes. My advice is to start by federating your existing services, get Rover and schema checks into CI early, and self-host the router in your VPC, allowing for managed control while keeping your data plane in your environment.
Which deployment model are you using for this solution?
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Front end workflow has become smoother and testing front–backend contracts is faster
What is our primary use case?
My main use case for Apollo GraphOS is on the front end, using React and TypeScript, where we have a BFF, a Backend for Frontend, doing an intermediary job between our service and our front end. In this intermediate layer, we used Apollo Client and the Explorer Sandbox Studio to consume GraphQL APIs in React as well.
Apollo GraphOS was fundamental in my day-to-day work. The backend has Swagger for us to test, but for the BFF, we always had to test through the BFF, since our front end consumed from there. It was very useful to use Apollo Playground to test queries and mutations all the time, both locally and with a built version.
In my workflow, Apollo Explorer comes in at the beginning of development of each screen. I test each query, each variable, and each mutation locally there before the front end actually consumes those queries and mutations. This makes it a way to validate even before pushing the code to production, which was very useful.
How has it helped my organization?
Apollo GraphOS had a positive impact on my organization because, without it, this work would be much more burdensome and much more difficult.
Apollo GraphOS facilitated the work between the BFF and the front end by reducing errors, because the schema between the BFF and the front end worked as a contract. I tested the query in the Explorer and aligned the data format with the person who took care of the BFF, which avoided a lot of back and forth. Also, because we used TypeScript at the same time, wrong fields appeared early, before reaching production. Using the Playground helped a lot, so we didn’t have to do curls via the terminal; instead, we had a visual interface to test more quickly and easily.
What is most valuable?
In my opinion, the best features that Apollo GraphOS offers are the Playground and the Explorer, which allowed us to quickly test queries and variables without deploying the application. I also appreciate Apollo Client for its cache, which is heavily used in all our applications and avoids repeated GraphQL requests. From what I know, schema checks help to avoid breaking the front end with changes that happen in the backend, for example.
The main point is that these features made my development easier by enabling testing before coding, which brought concrete benefits to my team.
What needs improvement?
An improvement I would suggest for Apollo GraphOS is in the initial setup, which could have fewer configurations of API keys, CI/CD, or routers. Pricing could also be clearer, with more transparency about the plans to make it clear what is paid and what is free. Most of the features we use are free, but we were confused when deciding whether to use it or not. Debugging Apollo Client’s cache could also have better tools to understand when something became outdated, for example.
For how long have I used the solution?
I have been using Apollo GraphOS for approximately two years, which was when I joined. They have been using it since then, and when I joined, it was already well used.
What do I think about the stability of the solution?
Apollo GraphOS is stable.
What do I think about the scalability of the solution?
Apollo GraphOS has both vertical and horizontal scalability.
Which solution did I use previously and why did I switch?
I didn’t previously use a different solution because, since the beginning, from the conception of all the projects where I’m working, we have used Apollo GraphOS.
What's my experience with pricing, setup cost, and licensing?
I mentioned the setup costs earlier.
Which other solutions did I evaluate?
Before choosing Apollo GraphOS, we looked at other options such as Hasura, GraphQL Mesh, and I believe WunderGraph, which is a good open-source option.
What other advice do I have?
I can’t give a score of 10 to Apollo GraphOS because it can be used in several contexts, and while it is great in my context, I can’t give a score of 10 for any type of solution in any type of context. I decided to give it an eight because it is very good software and technology, which helps a lot, but it’s not perfect.
I believe it is very interesting to be concerned about governance, mainly user security.
I believe they can go ahead and that they will have a very satisfactory result with Apollo GraphOS.
Federation has unified our microservices and streamlines independent GraphQL development
What is our primary use case?
I use Apollo GraphOS for GraphQL Federation between our microservices to provide GraphQL across multiple domains.
When a developer works on a domain consisting of a couple of microservices, or even one, backend work sometimes requires GraphQL updates. Instead of maintaining a GraphQL monolith that always needs to be rebuilt with changes, the GraphQL changes remain isolated to that service. The service is then deployed independently, which saves both deployment time and development time.
What is most valuable?
GraphQL Federation is the primary feature I have used, and it is excellent.
The flexibility and scalability of GraphQL Federation are what I find most valuable. These capabilities allowed us to use GraphQL, and I am uncertain we would have adopted GraphQL without Apollo's Federation.
Apollo GraphOS has positively impacted our organization by allowing us to streamline our GraphQL APIs for the front end and enabling us to grow much faster. We can add more services and schemas to the Federation and scale effectively.
What needs improvement?
There were some features needed in the Federation, but I cannot think of anything specific regarding how Apollo GraphOS could be improved at this time.
The documentation about the Federation could be clearer. It was sometimes difficult to find good examples or locate additional examples for certain topics.
For how long have I used the solution?
I have been using Apollo GraphQL Federation for three to four years, though I have not directly used Apollo GraphOS itself.
What other advice do I have?
I would rate Apollo GraphOS a nine overall.
I gave it a nine because it is excellent, but the documentation could be better.
We use the open source Apollo GraphQL libraries.
Apollo GraphOS is the best way to implement GraphQL with microservices. I would recommend this approach to others considering Apollo GraphOS.