Apollo Server Express vs express-graphql: Building GraphQL APIs in Express

Both apollo-server-express and express-graphql let you add a GraphQL endpoint to an Express.js application. They handle the core job of parsing incoming GraphQL queries, executing them against your schema, and returning structured JSON responses. But they differ significantly in features, flexibility, and current maintenance status. Let’s compare how they work in real projects.

⚠️ Maintenance Status: Active vs Deprecated

express-graphql is officially deprecated. The npm page states: "This package is no longer maintained. We recommend you use Apollo Server instead." The GitHub repository is archived, and no new features or fixes are being accepted.

// ❌ Do not use in new projects
const graphqlHTTP = require('express-graphql');

apollo-server-express is actively maintained as part of the Apollo Server ecosystem. It receives regular updates, security patches, and integrates with modern GraphQL tooling like Apollo Studio.

// ✅ Actively maintained
const { ApolloServer } = require('apollo-server-express');

💡 Bottom line: For any new project, express-graphql should be ruled out immediately due to deprecation.

🧱 Core Setup: Schema and Server Wiring

Both packages require a GraphQL schema, but their setup patterns differ.

express-graphql uses middleware that attaches directly to an Express app:

// express-graphql setup
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const schema = buildSchema(`
  type Query {
    hello: String
  }
`);

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

apollo-server-express uses a class-based server that must be started after Express middleware is applied:

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

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

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

async function startServer() {
  const app = express();
  const server = new ApolloServer({ typeDefs, resolvers });
  await server.start();
  server.applyMiddleware({ app });
  app.listen(4000);
}
startServer();

🔍 Developer Experience: Built-in Tooling

express-graphql includes GraphiQL (a basic GraphQL IDE) via the graphiql: true option. That’s about it for DX features.

// express-graphql: enable GraphiQL
app.use('/graphql', graphqlHTTP({ schema, graphiql: true }));

apollo-server-express offers Apollo Sandbox — a modern, feature-rich GraphQL IDE — enabled by default in development. It also supports persisted queries, query validation rules, and plugin hooks.

// apollo-server-express: Sandbox is on by default
// No extra config needed in dev mode
const server = new ApolloServer({ typeDefs, resolvers });

🛠️ Error Handling and Formatting

express-graphql returns raw GraphQL errors in the response. You can customize formatting with a formatError function, but it’s limited.

// express-graphql error formatting
app.use('/graphql', graphqlQHTTP({
  schema,
  formatError: (error) => ({
    message: error.message,
    code: error.originalError?.code
  })
}));

apollo-server-express provides structured error handling through plugins and the formatError option, with better support for masking internal errors in production.

// apollo-server-express error formatting
const server = new ApolloServer({
  typeDefs,
  resolvers,
  formatError: (error) => {
    // Don't expose internal details in prod
    return process.env.NODE_ENV === 'production'
      ? { message: 'Internal server error' }
      : error;
  }
});

📦 Advanced Features: What’s Included?

express-graphql is minimal by design. It does one thing: run GraphQL queries. No built-in support for subscriptions, file uploads, caching hints, or tracing.

apollo-server-express includes many production-ready features out of the box:

• Subscriptions (via WebSocket)
• File uploads (with graphql-upload integration)
• Automatic persisted queries
• Usage reporting to Apollo Studio
• Response caching with cacheControl

Example: enabling caching hints in Apollo Server:

// apollo-server-express: cache control
const resolvers = {
  Query: {
    post: (parent, args, context, info) => {
      info.cacheControl.setCacheHint({ maxAge: 60 });
      return getPost(args.id);
    }
  }
};

express-graphql has no equivalent.

🔒 Security and Validation

Both allow custom validation rules, but apollo-server-express makes it easier to apply them consistently and integrates with Apollo Studio for query depth/complexity analysis.

// apollo-server-express: custom validation
const { depthLimit } = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(5)]
});

In express-graphql, you’d pass validationRules to the middleware options, but without tooling support, it’s harder to monitor effectiveness.

🔄 Context and Request Integration

Both support passing request-specific data (like user info) via context.

express-graphql:

app.use('/graphql', graphqlHTTP({
  schema,
  context: ({ req }) => ({
    user: req.user
  })
}));

apollo-server-express:

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => ({
    user: req.user
  })
});

The pattern is nearly identical, so this isn’t a differentiator.

🧪 Testing and Mocking

apollo-server-express provides utilities like createTestClient for easy unit testing of resolvers.

// apollo-server-express: testing
const { createTestClient } = require('apollo-server-testing');
const server = new ApolloServer({ typeDefs, resolvers });
const { query } = createTestClient(server);
const res = await query({ query: '{ hello }' });

express-graphql has no official testing helpers—you’d need to mock Express requests manually.

📊 Summary: Key Differences

💡 Final Recommendation

Do not use express-graphql in any new project. It’s deprecated, lacks modern GraphQL features, and won’t receive security updates.

Use apollo-server-express if you’re building a production GraphQL API on top of Express. It gives you enterprise-grade tooling, active maintenance, and a clear upgrade path to newer Apollo Server versions (including standalone servers that don’t require Express).

If you’re starting fresh and don’t need Express for other routes, consider using apollo-server (standalone) instead—it removes the Express dependency entirely while keeping the same core API.