apollo-server vs express-graphql vs graphql-tools
GraphQL Server Implementation and Schema Management in Node.js
Search packages..
apollo-serverexpress-graphqlgraphql-toolsSimilar Packages:

GraphQL Server Implementation and Schema Management in Node.js

apollo-server, express-graphql, and graphql-tools are foundational packages in the Node.js GraphQL ecosystem, each serving distinct but sometimes overlapping roles. apollo-server is a standalone GraphQL server implementation that includes built-in support for Express and other web frameworks, offering features like schema stitching, subscriptions, and developer tooling. express-graphql is a minimal middleware that adds GraphQL execution to an existing Express application, relying on the core graphql package for query resolution. graphql-tools provides utilities for constructing and manipulating GraphQL schemas programmatically, notably through the makeExecutableSchema function, and is often used alongside server implementations to define resolvers and type definitions cleanly.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
apollo-server013,93626.6 kB833 years agoMIT
express-graphql06,272-556 years agoMIT
graphql-tools05,4272.61 kB159a month agoMIT

Building GraphQL Servers in Node.js: apollo-server vs express-graphql vs graphql-tools

When setting up a GraphQL API in Node.js, developers often encounter three key packages: apollo-server, express-graphql, and graphql-tools. While they all relate to GraphQL, they serve different purposes—one is a full server, one is a lightweight middleware, and one is a schema utility library. Understanding their roles prevents architectural missteps, especially since one of them is no longer maintained.

⚠️ Deprecation Status: Know Before You Build

First, a critical update: express-graphql is officially deprecated. The npm page states: "This package is no longer maintained. We recommend using Apollo Server instead." This means you should not use express-graphql in new projects. We include it here only for context and migration guidance.

In contrast, both apollo-server and graphql-tools are actively maintained and widely used in production systems.

🧱 Core Responsibilities: What Each Package Actually Does

apollo-server: Full-Featured GraphQL Server

apollo-server is a complete GraphQL server implementation. It handles HTTP requests, parses queries, executes resolvers, formats errors, and serves GraphQL Playground (in development). It can run standalone or integrate with Express, Koa, Hapi, and more.

// apollo-server: Standalone server
import { ApolloServer } from 'apollo-server';
import { typeDefs, resolvers } from './schema.js';

const server = new ApolloServer({ typeDefs, resolvers });
server.listen().then(({ url }) => console.log(`Server ready at ${url}`));

express-graphql: Minimal Express Middleware (Deprecated)

express-graphql is just a middleware that plugs GraphQL execution into an Express app. It delegates almost everything to the graphql package and offers minimal configuration.

// express-graphql: Deprecated usage
import express from 'express';
import { graphqlHTTP } from 'express-graphql';
import { schema } from './schema.js';

const app = express();
app.use('/graphql', graphqlHTTP({ schema, graphiql: true }));
app.listen(4000);

🔴 Do not use this in new code. Migrate to Apollo Server if you're maintaining an old codebase.

graphql-tools: Schema Construction Utilities

graphql-tools doesn’t run a server—it helps you build schemas. Its flagship function, makeExecutableSchema, combines type definitions (SDL) and resolver objects into a single executable schema object that any GraphQL server can use.

// graphql-tools: Schema creation
import { makeExecutableSchema } from 'graphql-tools';

const typeDefs = `
  type Query {
    hello: String
  }
`;

const resolvers = {
  Query: { hello: () => 'Hello world!' }
};

const schema = makeExecutableSchema({ typeDefs, resolvers });
// Now pass `schema` to Apollo Server, Yoga, or any other server

🛠️ Real-World Integration Patterns

Using graphql-tools with apollo-server

Most professional Apollo Server setups use graphql-tools under the hood (even if indirectly). Here’s how they work together:

// Combined: graphql-tools + apollo-server
import { ApolloServer } from 'apollo-server';
import { makeExecutableSchema } from 'graphql-tools';

const schema = makeExecutableSchema({
  typeDefs: `type Query { user(id: ID!): User } type User { id: ID! name: String }`,
  resolvers: {
    Query: { user: (_, { id }) => ({ id, name: 'Alice' }) }
  }
});

const server = new ApolloServer({ schema });
server.listen();

Note: Modern Apollo Server versions accept typeDefs and resolvers directly and internally use graphql-tools, so explicit makeExecutableSchema isn’t always needed—but it’s still useful for advanced cases like schema merging.

Why Not Use express-graphql Today?

Beyond deprecation, express-graphql lacks:

  • Built-in support for GraphQL subscriptions
  • File upload handling
  • Structured error formatting
  • Plugin system for observability
  • Security features like depth limiting

Apollo Server provides all these out of the box.

🧩 Advanced Schema Workflows with graphql-tools

Where graphql-tools shines is in complex schema management:

Schema Stitching (Legacy Federation)

Before Apollo Federation, graphql-tools enabled combining multiple GraphQL services into one schema:

import { stitchSchemas } from 'graphql-tools';

const gatewaySchema = stitchSchemas({
  subschemas: [
    { schema: userServiceSchema },
    { schema: orderServiceSchema }
  ]
});

Note: For new microservices, use Apollo Federation instead—but graphql-tools still powers many stitching-based systems.

Mocking for Development

Generate realistic mock data from your schema:

import { addMocksToSchema } from 'graphql-tools';

const mockedSchema = addMocksToSchema({ schema });
// Now all resolvers return auto-generated mock data

This is invaluable for frontend teams working before backend APIs are ready.

🔒 Error Handling and Developer Experience

Apollo Server

Provides structured error formatting, masking stack traces in production, and extension points:

const server = new ApolloServer({
  formatError: (err) => ({
    message: err.message,
    code: err.extensions?.code || 'INTERNAL_ERROR'
  })
});

express-graphql (Deprecated)

Offers basic error handling but no customization hooks beyond a global formatError option.

graphql-tools

Not applicable—it doesn’t handle runtime execution, so no error formatting.

📦 When to Use Which: Practical Guidance

ScenarioRecommended Package(s)
New GraphQL API from scratchapollo-server (with or without explicit graphql-tools)
Need modular schema design or mockinggraphql-tools + any server (e.g., Apollo Server)
Maintaining old Express app with GraphQLMigrate from express-graphql to apollo-server-express
Building a GraphQL gatewayUse @apollo/server with Federation, not graphql-tools stitching

💡 Key Takeaways

  • apollo-server is your go-to for production GraphQL servers—feature-rich, secure, and well-supported.
  • express-graphql is deprecated. Avoid it in new projects; plan to migrate existing uses.
  • graphql-tools is not a server—it’s a toolkit for schema authoring, testing, and composition. It complements server libraries rather than replacing them.

In modern architectures, you’ll often see apollo-server and graphql-tools used together: the former runs the API, the latter builds the schema. Understanding this division of labor leads to cleaner, more maintainable GraphQL implementations.

How to Choose: apollo-server vs express-graphql vs graphql-tools

  • apollo-server:

    Choose apollo-server if you need a production-ready, batteries-included GraphQL server with integrated tooling like Apollo Studio, persisted queries, and built-in support for subscriptions and file uploads. It’s ideal for teams building full-featured GraphQL APIs who want conventions, security defaults, and extensibility without assembling low-level pieces manually.

  • express-graphql:

    Choose express-graphql only if you’re maintaining a legacy Express app that already uses this middleware and you need minimal GraphQL integration without additional dependencies. Note that it is officially deprecated and should not be used in new projects — consider migrating to Apollo Server or another modern alternative.

  • graphql-tools:

    Choose graphql-tools when you need flexible, programmatic schema construction—especially for modular schema design, schema merging, or mock generation—without tying yourself to a specific server implementation. It pairs well with any GraphQL server (including Apollo Server) and is essential for advanced schema workflows like federation or testing.

Similar Npm Packages to apollo-server

apollo-server is a community-driven, open-source GraphQL server that works with any GraphQL schema. It is designed to be easy to set up and use, providing a robust set of features out of the box, including support for subscriptions, middleware, and more. Apollo Server integrates seamlessly with various Node.js frameworks, making it a popular choice for developers looking to implement GraphQL APIs in their applications. Its extensive documentation and active community support further enhance its usability, making it suitable for both beginners and experienced developers.

An alternative to Apollo Server is express-graphql. This library is a middleware for Express that allows you to create a GraphQL API easily. It provides a simple way to set up a GraphQL server using Express, enabling you to define your schema and resolvers while leveraging the existing Express ecosystem. While express-graphql is lightweight and straightforward, it may require more manual setup compared to Apollo Server, which comes with built-in features like performance tracing and error handling.

For a detailed comparison of these two packages, check out the following link: Comparing apollo-server vs express-graphql.

Similar Npm Packages to express-graphql

express-graphql is a middleware for integrating GraphQL with Express.js, allowing developers to build GraphQL APIs easily and efficiently. It provides a straightforward way to set up a GraphQL server, enabling developers to define their schema and resolvers while leveraging the power of Express.js for handling HTTP requests. With express-graphql, you can quickly create a robust GraphQL endpoint that can serve complex data queries and mutations.

While express-graphql is a popular choice for building GraphQL APIs, there are other libraries that serve similar purposes. Here are a few alternatives:

  • apollo-server-express is part of the Apollo Server ecosystem, which is widely used for building GraphQL APIs. It integrates seamlessly with Express.js, providing a rich set of features such as built-in support for subscriptions, caching, and performance tracing. Apollo Server also offers a powerful developer experience with tools like Apollo Client and Apollo Studio, making it an excellent choice for developers looking for a comprehensive solution for building GraphQL APIs.
  • graphql-yoga is a fully-featured GraphQL server that is easy to set up and use. It is built on top of Express.js and provides a simple API for creating GraphQL servers with features like real-time subscriptions, file uploads, and more. graphql-yoga is designed to be flexible and extensible, making it suitable for both small projects and larger applications. Its simplicity and ease of use make it a great option for developers looking to get started with GraphQL quickly.

To see how express-graphql compares with apollo-server-express and graphql-yoga, check out the comparison: Comparing apollo-server-express vs express-graphql vs graphql-yoga.

Similar Npm Packages to graphql-tools

graphql-tools is a powerful set of utilities for building GraphQL schemas and resolvers in JavaScript. It provides developers with tools to create, manipulate, and extend GraphQL schemas easily, making it a popular choice for those looking to implement GraphQL in their applications. With features like schema stitching, merging, and type definitions, graphql-tools simplifies the process of building a robust GraphQL API. However, there are other libraries in the GraphQL ecosystem that also serve similar purposes. Here are a few alternatives:

  • apollo-server is a community-driven, open-source GraphQL server that is designed to work seamlessly with Apollo Client. It provides a straightforward way to set up a GraphQL server with built-in support for features like subscriptions, file uploads, and more. apollo-server is ideal for developers looking for a comprehensive solution that integrates well with the Apollo ecosystem, making it easier to manage both client and server-side GraphQL implementations. Its extensive documentation and community support make it a go-to choice for many developers.
  • express-graphql is a middleware for integrating GraphQL with Express, one of the most popular web frameworks for Node.js. It allows developers to create a GraphQL API quickly and easily by leveraging the existing Express infrastructure. express-graphql is a great choice if you are already using Express in your application and want to add GraphQL capabilities without introducing a new framework. It provides a simple way to define your schema and resolvers while benefiting from the flexibility and middleware capabilities of Express.

To see how graphql-tools compares with apollo-server and express-graphql, check out the comparison: Comparing graphql-tools vs apollo-server vs express-graphql.

README for apollo-server

Apollo Server

A TypeScript GraphQL Server for Express, Koa, Hapi, Lambda, and more.

npm version Build Status Join the community forum Read CHANGELOG

Apollo Server is a community-maintained open-source GraphQL server. It works with many Node.js HTTP server frameworks, or can run on its own with a built-in Express server. Apollo Server works with any GraphQL schema built with GraphQL.js--or define a schema's type definitions using schema definition language (SDL).

Read the documentation for information on getting started and many other use cases and follow the CHANGELOG for updates.

Principles

Apollo Server is built with the following principles in mind:

  • By the community, for the community: Its development is driven by the needs of developers.
  • Simplicity: By keeping things simple, it is more secure and easier to implement and contribute.
  • Performance: It is well-tested and production-ready.

Anyone is welcome to contribute to Apollo Server, just read CONTRIBUTING.md, take a look at the roadmap and make your first PR!

Getting started

To get started with Apollo Server:

  • Install with npm install apollo-server-<integration> graphql
  • Write a GraphQL schema
  • Use one of the following snippets

There are two ways to install Apollo Server:

  • Standalone: For applications that do not require an existing web framework, use the apollo-server package.
  • Integrations: For applications with a web framework (e.g. express, koa, hapi, etc.), use the appropriate Apollo Server integration package.

For more info, please refer to the Apollo Server docs.

Installation: Standalone

In a new project, install the apollo-server and graphql dependencies using:

npm install apollo-server graphql

Then, create an index.js which defines the schema and its functionality (i.e. resolvers):

const { ApolloServer, gql } = require('apollo-server');

// The GraphQL schema
const typeDefs = gql`
  type Query {
    "A simple type for getting started!"
    hello: String
  }
`;

// A map of functions which return data for the schema.
const resolvers = {
  Query: {
    hello: () => 'world',
  },
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
});

server.listen().then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});

Due to its human-readability, we recommend using schema-definition language (SDL) to define a GraphQL schema--a GraphQLSchema object from graphql-js can also be specified instead of typeDefs and resolvers using the schema property:

const server = new ApolloServer({
  schema: ...
});

Finally, start the server using node index.js and go to the URL returned on the console.

For more details, check out the Apollo Server Getting Started guide and the fullstack tutorial.

For questions, the Apollo community forum is a great place to get help.

Installation: Integrations

While the standalone installation above can be used without making a decision about which web framework to use, the Apollo Server integration packages are paired with specific web frameworks (e.g. Express, Koa, hapi).

The following web frameworks have Apollo Server integrations, and each of these linked integrations has its own installation instructions and examples on its package README.md:

Context

A request context is available for each request. When context is defined as a function, it will be called on each request and will receive an object containing a req property, which represents the request itself.

By returning an object from the context function, it will be available as the third positional parameter of the resolvers:

new ApolloServer({
  typeDefs,
  resolvers: {
    Query: {
      books: (parent, args, context, info) => {
        console.log(context.myProperty); // Will be `true`!
        return books;
      },
    }
  },
  context: async ({ req }) => {
    return {
      myProperty: true
    };
  },
})

Documentation

The Apollo Server documentation contains additional details on how to get started with GraphQL and Apollo Server.

The raw Markdown source of the documentation is available within the docs/ directory of this monorepo--to contribute, please use the Edit on GitHub buttons at the bottom of each page.

Development

If you wish to develop or contribute to Apollo Server, we suggest the following:

  • Fork this repository

  • Install Direnv (a tool that automatically sets up environment variables in project directories) or nvm. We use nvm to ensure we're running the expected version of Node (and we use Direnv to install and run nvm automatically).

  • Install the Apollo Server project on your computer

git clone https://github.com/[your-user]/apollo-server
cd apollo-server
direnv allow  # sets up nvm for you; if you installed nvm yourself, try `nvm install` instead
  • Build and test
npm install
npm test
  • To run individual test files, run npm run pretest && npx jest packages/apollo-server-foo/src/__tests__/bar.test.ts. Note that you do need to re-compile TypeScript before each time you run a test, or changes across packages may not be picked up. Instead of running npm run pretest from scratch before each test run, you can also run tsc --build tsconfig.json --watch in another shell, or use the VSCode Run Build Task to run that for you.

Community

Are you stuck? Want to contribute? Come visit us in the Apollo community forum!

Maintainers

Who is Apollo?

Apollo builds open-source software and a graph platform to unify GraphQL across your apps and services. We help you ship faster with:

  • Apollo Studio – A free, end-to-end platform for managing your GraphQL lifecycle. Track your GraphQL schemas in a hosted registry to create a source of truth for everything in your graph. Studio provides an IDE (Apollo Explorer) so you can explore data, collaborate on queries, observe usage, and safely make schema changes.
  • Apollo Federation – The industry-standard open architecture for building a distributed graph. Use Apollo’s gateway to compose a unified graph from multiple subgraphs, determine a query plan, and route requests across your services.
  • Apollo Client – The most popular GraphQL client for the web. Apollo also builds and maintains Apollo iOS and Apollo Android.
  • Apollo Server – A production-ready JavaScript GraphQL server that connects to any microservice, API, or database. Compatible with all popular JavaScript frameworks and deployable in serverless environments.

Learn how to build with Apollo

Check out the Odyssey learning platform, the perfect place to start your GraphQL journey with videos and interactive code challenges. Join the Apollo Community to interact with and get technical help from the GraphQL community.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.