How can I use OpenAPI with GraphQL?

How can I use OpenAPI with GraphQL? #

APIs (Application Programming Interfaces) are crucial for modern software development as they enable different applications to interact with one another. OpenAPI and GraphQL are two popular specifications for building APIs. OpenAPI is traditionally used for RESTful APIs while GraphQL is a query language for APIs. Integrating these two can bring a number of benefits such as enhanced flexibility, better documentation, and more efficient querying capabilities. This article explores how you can use OpenAPI with GraphQL.

Understanding OpenAPI and GraphQL #

Before diving into how you can integrate OpenAPI with GraphQL, let’s understand what each of these technologies brings to the table.

OpenAPI #

OpenAPI Specification (OAS) is a standard for defining RESTful APIs. OpenAPI uses a YAML or JSON format to describe the API’s endpoints, request parameters, responses, and other metadata. It is a powerful tool for:

  • Documentation: Detailed API docs are auto-generated from the OpenAPI file.
  • Validation: Tools can automatically validate requests and responses.
  • Code Generation: Client and server stubs can be auto-generated in various languages.

GraphQL #

GraphQL is a query language and runtime for executing queries against your API. Developed by Facebook, GraphQL provides a more flexible and efficient way to interact with APIs by:

  • Allowing Clients to Specify Data Needs: Clients can request specific fields, reducing over-fetching and under-fetching of data.
  • Single Endpoint: Unlike REST, which has multiple endpoints for different resources, a GraphQL API serves requests through a single endpoint.
  • Introspection: GraphQL has built-in introspection capabilities, allowing clients to query the schema for available types and fields.

Benefits of Combining OpenAPI with GraphQL #

Combining OpenAPI and GraphQL allows you to leverage the strengths of both while mitigating their weaknesses. Here are some benefits:

  • Rich Documentation and Strong Typing: OpenAPI provides comprehensive documentation that can complement GraphQL’s self-documenting schema.
  • Enhanced Flexibility: GraphQL’s ability to fetch only the necessary data can help optimize performance.
  • Code Reuse: Tools can be developed to convert OpenAPI specifications to GraphQL schemas, promoting code reuse and easier maintenance.

Methods for Integrating OpenAPI with GraphQL #

There are several methods to integrate OpenAPI with GraphQL, each with its own advantages and use cases.

1. Using GraphQL API Gateway #

A GraphQL API Gateway can act as a façade that aggregates multiple RESTful services behind a single GraphQL endpoint. Tools like Apollo Gateway, Hasura, and Prisma help you stitch together services defined by OpenAPI.


  1. Create OpenAPI Specification: Begin by creating an OpenAPI specification for your RESTful API.
  2. Generate GraphQL Schema: Use tools such as Apollo Gateway or swagger-to-graphql to convert the OpenAPI Specification into a GraphQL schema.
  3. Setup Resolvers: Configure the GraphQL server to resolve GraphQL queries to the corresponding OpenAPI endpoints.
  4. Deploy the Gateway: Deploy your GraphQL API Gateway.

Example Code (Apollo Gateway):

const { ApolloServer } = require('apollo-server');
const { ApolloGateway } = require('@apollo/gateway');

const gateway = new ApolloGateway({
  serviceList: [
    { name: 'service1', url: 'http://service1/graphql' },
    { name: 'service2', url: 'http://service2/graphql' },

const server = new ApolloServer({ gateway });

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

2. Middleware for API Translation #

Another approach is to use middleware that translates between OpenAPI and GraphQL. This middleware can intercept incoming GraphQL queries and translate them into corresponding OpenAPI requests.


  1. Setup OpenAPI Specification: Define your API using OpenAPI.
  2. Choose Middleware Tool: Use middleware like graphql-mesh.
  3. Configure Middleware: Configure the middleware to convert requests and responses.

Example Code (GraphQL Mesh):

// mesh.config.yaml
  - name: ExampleAPI
        source: ./path-to-your-openapi-spec.yaml
const { getMesh } = require('@graphql-mesh/runtime');
const { findAndParseConfig } = require('@graphql-mesh/config');

async function main() {
  const config = await findAndParseConfig();
  const { schema, contextBuilder } = await getMesh(config);

  const server = new ApolloServer({ schema, contextBuilder });

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


3. Manual Schema Definition and Resolver Configuration #

In some cases, you might prefer the control of writing your GraphQL schema and resolvers manually, using existing OpenAPI documentation as a reference.


  1. Reference OpenAPI Specification: Use the OpenAPI specification for defining the GraphQL schema.
  2. Write Schema: Define your GraphQL schema manually.
  3. Implement Resolvers: Implement resolvers to handle the queries and mutations.

Example Code:

# schema.graphql
type Query {
  getUser(id: ID!): User

type User {
  id: ID!
  name: String
  email: String
// resolvers.js
const fetch = require('node-fetch');

const resolvers = {
  Query: {
    getUser: async (_, { id }) => {
      const response = await fetch(`http://openapi-service/users/${id}`);
      return response.json();

module.exports = resolvers;
// server.js
const { ApolloServer, gql } = require('apollo-server');
const resolvers = require('./resolvers');
const fs = require('fs');

const schema = fs.readFileSync('./schema.graphql', 'utf8');

const server = new ApolloServer({
  typeDefs: gql(schema),

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

Tools and Resources #

Here are some tools and resources to help you get started with combining OpenAPI and GraphQL:

  1. Apollo Federation and Apollo Gateway: For setting up a GraphQL gateway that can aggregate multiple services.
  2. Hasura: Provides instant GraphQL APIs on existing REST endpoints.
  3. graphql-mesh: Supports a variety of data sources, including OpenAPI, and stitches them into a single GraphQL endpoint.
  4. swagger-to-graphql: Converts an OpenAPI/Swagger spec into a GraphQL schema.

Conclusion #

Using OpenAPI with GraphQL is a flexible strategy that combines the strengths of both technologies. Whether you use a GraphQL API Gateway, middleware for API translation, or manually define your schemas and resolvers, the integration can significantly enhance the capabilities of your API infrastructure.

By leveraging tools like Apollo Gateway, Hasura, and graphql-mesh, you can efficiently bridge the gap between RESTful OpenAPI services and the powerful querying capabilities of GraphQL. This not only improves the flexibility and efficiency of your API interactions but also streamlines the development and maintenance process. If you’re looking to get started, numerous libraries and frameworks are available to help you integrate OpenAPI with GraphQL seamlessly.

For more information on these approaches, you might want to explore the Apollo Federation documentation, Hasura’s guide on connecting REST endpoints, and graphql-mesh documentation.

This website is not affiliated with the OpenAPI Initiative.