Connect MongoDB Atlas GraphQL API to your WebApp - Tutorial


To connect MongoDB Atlas GraphQL to your web app, you can follow these steps:

  1. Create a GraphQL schema for your app. This will define the types of data that your app will use and how they are related. You can use tools like Apollo Studio to help you create and manage your schema.

  2. Set up a MongoDB Atlas cluster and create a database that will store the data for your app.

  3. Enable GraphQL API access in your Atlas cluster. This will allow you to use the GraphQL API to query and mutate data in your Atlas database.

  4. Use a GraphQL client library, such as Apollo Client, to connect to your Atlas GraphQL API from your web app. This library will allow you to perform GraphQL queries and mutations from your app.

  5. Write your app code to use the GraphQL client library to communicate with your Atlas GraphQL API. You can use the Apollo Client library to handle state management and data fetching in your app.

  6. Test your app to make sure that it is able to query and mutate data in your Atlas database through the GraphQL API.

NOW how do we do this? See Below:

Connect a React web app to a MongoDB Atlas GraphQL API using Apollo Client:

To connect a React web app to a MongoDB Atlas GraphQL API using Apollo Client, you need to follow these steps:

  1. Install the required packages:

    npm install apollo-boost react-apollo graphql-tag graphql --save
  2. Set up the Apollo client with the GraphQL endpoint:

    import ApolloClient from 'apollo-boost';
    const client = new ApolloClient({
      uri: 'https://your-graphql-api-endpoint',
  3. Wrap your root component with the ApolloProvider and pass the Apollo client instance:

    import React from 'react';
    import ReactDOM from 'react-dom';
    import { ApolloProvider } from 'react-apollo';
    import App from './App';
    import client from './apolloClient';
      <ApolloProvider client={client}>
        <App />
  4. Define your GraphQL queries and mutations using the gql tag from graphql-tag:

    import gql from 'graphql-tag';
    export const GET_BOOKS = gql`
      query {
        books {
    export const ADD_BOOK = gql`
      mutation addBook($title: String!, $author: String!) {
        addBook(title: $title, author: $author) {
  5. Use the Query and Mutation components from react-apollo to fetch data and perform mutations:

    import React from 'react';
    import { Query, Mutation } from 'react-apollo';
    import { GET_BOOKS, ADD_BOOK } from './queries';
    function App() {
      return (
          <Query query={GET_BOOKS}>
            {({ loading, error, data }) => {
              if (loading) return <p>Loading...</p>;
              if (error) return <p>Error :(</p>;
              return{ id, title, author }) => (
                <div key={id}>
                  <p>Title: {title}</p>
                  <p>Author: {author}</p>
            update={(cache, { data: { addBook } }) => {
              const { books } = cache.readQuery({ query: GET_BOOKS });
                query: GET_BOOKS,
                data: { books: books.concat([addBook]) },
            {(addBook, { loading, error }) => (
                onSubmit={e => {
                    variables: {
         = '';
         = '';
                <input name="title" />
                <input name="author" />
                <button type="submit">Add Book</button>
                {loading && <p>Loading...</p>}
                {error && <p>Error :( Please try again</p>}
    export default App;

    In the example above, the Query component is used to fetch data using the GET_BOOKS query, and the Mutation component is used to perform a mutation using the ADD_BOOK mutation. The update function is used to update the fields as they change.