Cassiano Ziegler Bein

MongoDB Atlas is an awesome Cloud Data Platform providing an immense amount of automation to set up your databases, data lakes, charts, full-text search indexes, and more across all major cloud providers around the globe. Through the MongoDB Atlas GUI, you can easily deploy a fully scalable global cluster across several regions and even across different cloud providers in a matter of minutes. That's what I call automation. Using the MongoDB GUI is super intuitive and great, but how can I manage all these features in my own way?

The answer is simple and you probably already know it….**APIs**!

![Did I hear API?](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/did_i_hear_api_4069df724d.png)

MongoDB Atlas has a full featured API which allows users to programmatically manage all Atlas has to offer.

The main idea is to enable users to integrate Atlas with all other aspects of your Software Development Life Cycle (SDLC), giving the ability for your DevOps team to create automation on their current processes across all their environments (Dev, Test/QA, UAT, Prod).

One example would be the DevOps teams leveraging APIs on the creation of ephemeral databases to run their CI/CD processes in lower environments for test purposes. Once it is done, you would just terminate the database deployment.

Another example we have seen DevOps teams using is to incorporate the creation of the databases needed into their Developers Portals. The idea is to give developers a self-service experience, where they can start a project by using a portal to provide all project characteristics (tech stack according to their coding language, app templates, etc.), and the portal will create all the automation to provide all aspects needed, such as a new code repo, CI/CD job template, Dev Application Servers, and a MongoDB database. So, they can start coding as soon as possible!

Even though the [MongoDB Atlas API Resources documentation](https://docs.atlas.mongodb.com/api/) is great with lots of examples using cURL, we thought developers would appreciate it if they could also have all these in one of their favorite tools to work with APIs. I am talking about [Postman](https://www.postman.com/downloads/), an API platform for building and using APIs. So, we did it! Below you will find step-by-step instructions on how to use it.

### Step 1: Configure your workstation/laptop

* [Download](https://www.postman.com/downloads/) and install Postman on your workstation/laptop.
* [Training](https://learning.postman.com/) on Postman is available if you need a refresher on how to use it.

### Step 2: Configure MongoDB Atlas

* Create a free [MongoDB Atlas account](https://account.mongodb.com/account/register) to have access to a free cluster to play around in. Make sure you create an organization and a project. Don't skip that step. Here is a coupon code—**GOATLAS10**—for some credits to explore more features (valid as of August 2021). Watch this [video](https://www.youtube.com/watch?v=FxeQ5eck3tw) to learn how to add these credits to your account.
* Create an [API key](https://docs.atlas.mongodb.com/configure-api-access/) with Organization Owner privileges and save the public/private key to use when calling APIs. Also, don't forget to add your laptop/workstation IP to the API access list.
* Create a [database deployment](https://docs.atlas.mongodb.com/create-database-deployment/#create-a-new-database-deployment) (cluster) via the Atlas UI or the MongoDB CLI (check out the [MongoDB CLI Atlas Quick Start](https://www.mongodb.com/blog/post/introducing-mongodb-cli-atlas-quick-start) for detailed instructions). Note that a free database deployment will allow you to run most of the API calls. Use an M10 database deployment or higher if you want to have full access to all of the APIs. Feel free to explore all of the other database deployment options, but the default options should be fine for this example.
* Navigate to your Project Settings and retrieve your Project ID so it can be used in one of our examples below.

![Finding your Project ID on MongoDB Atlas](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_atlas_project_id_7e84ef1db2.png)

### Step 3: Configure and use Postman

* Fork or Import the MongoDB Atlas Collection to your Postman Workspace:  
    [![Run in Postman](https://run.pstmn.io/button.svg)](https://god.gw.postman.com/run-collection/17637161-25049d75-bcbc-467b-aba0-82a5c440ee02?action=collection%2Ffork&collection-url=entityId%3D17637161-25049d75-bcbc-467b-aba0-82a5c440ee02%26entityType%3Dcollection%26workspaceId%3D8355a86e-dec2-425c-9db0-cb5e0c3cec02#?env%5BAtlas%5D=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)
* Click on the MongoDB Atlas Collection. Under the Authorization tab, choose the Digest Auth Type and use the *public key* as the *user* and the *private key* as your *password*.

![Configuring Authorization on Postman using MongoDB Atlas API key](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/postman_auth_config_d644e181dc.png)

* Open up the **Get All Clusters** API call under the cluster folder.

![Accessing Postman API Calls to MongoDB Atlas](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/postman_api_calls_e5317b661f.png)

* Make sure you select the Atlas environment variables and [update the Postman variable](https://learning.postman.com/docs/sending-requests/variables/) ProjectID value to your **Project ID** captured in the previous steps.

![Setting Postman variables](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/postman_variables_8c0bb2b3d7.png)

![Setting Postman variables in Atlas Environment variables](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/postman_variables_atlas_env_83abc36dc1.png)

* Execute the API call by hitting the Send button and you should get a response containing a list of all your clusters (database deployments) alongside the cluster details, like whether backup is enabled or the cluster is running.

![Executing API call to list all MongoDB Atlas cluster in your project.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/executing_api_call_bf5e1fd674.png)

Now explore all the APIs available to create your own automation.

One last tip: Once you have tested all your API calls to build your automation, Postman allows you to export that in code snippets in your favorite programming language.

![Generating Code snippet in Postman](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/generating_code_snippet_in_postman_9431e3320f.png)

![Generating Python Code snippet in Postman](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/generating_code_snippet_postman_6b6c83aae6.png)

Please always refer to the online [documentation](https://docs.atlas.mongodb.com/reference/api-resources/) for any changes or new resources. Also, feel free to make pull requests to update the project with new API resources, fixes, and enhancements.

Hope you enjoyed it! Please share this with your team and community. It might be really helpful for everyone!

Here are some other great posts related to this subject:

* [Programmatic API Management of Your MongoDB Atlas Database Clusters](https://www.mongodb.com/blog/post/programmatic-api-management-of-your-mongodb-atlas-database-clusters)
* [Programmatic API Management of Your MongoDB Atlas Database Clusters - Part II](https://www.mongodb.com/blog/post/programmatic-api-management-of-your-mongodb-atlas-database-clusters-part-ii)
* [Calling the MongoDB Atlas API - How to Do it from Node, Python, and Ruby](https://www.mongodb.com/developer/how-to/nodejs-python-ruby-atlas-api/)

\**A subset of API endpoints are supported in (free) M0, M2, and M5 clusters.*

Public Repo - [https://github.com/cassianobein/mongodb-atlas-api-resources](https://github.com/cassianobein/mongodb-atlas-api-resources)  
Atlas API Documentation - [https://docs.atlas.mongodb.com/api/](https://docs.atlas.mongodb.com/api/)  
Postman MongoDB Public Workspace - [https://www.postman.com/mongodb-devrel/workspace/mongodb-public/overview](https://www.postman.com/mongodb-devrel/workspace/mongodb-public/overview)  

Build your own automation with MongoDB Atlas API resources.

Automate the Automation on MongoDB Atlas

Joel Lord

> This tutorial discusses the preview version of the Atlas Data API which is now generally available with more features and functionality. Learn more about the GA version [here](https://www.mongodb.com/developer/products/atlas/atlas-data-api-introduction/).

MongoDB's new [Data API](https://www.mongodb.com/data-api/lp) is a great way to access your MongoDB Atlas data using a REST-like interface. When enabled, the API creates a series of serverless endpoints that can be accessed without using [native drivers](https://docs.mongodb.com/drivers/). This API can be helpful when you need to access your data from an application that doesn't use those drivers, such as a bash script, a Google Sheet document, or even another database.

To explore the new MongoDB Data API, you can use the [public Postman workspace](https://www.postman.com/mongodb-devrel/workspace/mongodb-public/documentation/17898583-25682080-e247-4d25-8e5c-1798461c7db4) provided by the MongoDB developer relations team. 

In this article, we will show you how to use Postman to read and write to your MongoDB Atlas cluster.

## Getting started
You will need to set up your Altas cluster and fork the Postman collection to start using it. Here are the detailed instructions if you need them.
### Set up your MongoDB Atlas cluster
The first step to using the Data API is to create your own MongoDB Atlas cluster. If you don't have a cluster available already, you can [get one for free](https://www.mongodb.com/cloud/atlas/register). Follow the instructions from the [documentation](https://docs.atlas.mongodb.com/tutorial/deploy-free-tier-cluster/) for the detailed directions on setting up your MongoDB Atlas instance.

### Enable the Data API
Enabling the Data API on your MongoDB Atlas data collections is done with a few clicks. Once you have a cluster up and running, you can enable the Data API by following [these instructions](https://docs.atlas.mongodb.com/api/data-api/#1.-enable-the-data-api).
### Fork the Postman collection
You can use the button below to open the fork in your Postman workspace or follow the instructions provided in this section.

[![Run in Postman](https://run.pstmn.io/button.svg)](https://god.gw.postman.com/run-collection/17898583-25682080-e247-4d25-8e5c-1798461c7db4?action=collection%2Ffork&collection-url=entityId%3D17898583-25682080-e247-4d25-8e5c-1798461c7db4%26entityType%3Dcollection%26workspaceId%3D8355a86e-dec2-425c-9db0-cb5e0c3cec02)

From the [public MongoDB workspace](https://www.postman.com/mongodb-devrel/workspace/mongodb-public/overview) on Postman, you will find two collections. The second one from the list, the _MongoDB Data API_, is the one you are interested in. Click on the three dots next to the collection name and select _Create a fork_ from the popup menu.

![From the left navigation menu, select the three dots next to MongoDB Data API, then select Create a fork.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2022_01_13_at_11_15_42_AM_39131a4fba.png)

Then follow the instructions on the screen to add this collection to your workspace. By forking this collection, you will be able to pull the changes from the official collection as the API evolves.

### Fill in the required variables
You will now need to configure your Postman collections to be ready to use your MongoDB collection. Start by opening the _Variables_ tab in the Postman collection.

![A screenshot showing the variables that need to be filled in.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2022_01_13_at_1_56_17_PM_0cb57fdcb7.png)

You will need to fill in the values for each variable. If you don't want the variables to be saved in your collection, use the _Current value_ column. If you're going to reuse those same values next time you log in, use the _Initial value_ column.

For the `URL_ENDPOINT` variable, go to the Data API screen on your Atlas cluster. The URL endpoint should be right there at the top. Click on the _Copy_ button and paste the value in Postman.

![A screenshot showing how to get the URL endpoint from the Atlas UI.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2022_01_13_at_2_00_40_PM_17a6120334.png)

Next, for the `API_KEY`, click on _Create API Key_. This will open up a modal window. Give your key a unique name and click on _Generate Key_. Again, click on the _Copy_ button and paste it into Postman.

![A screenshot showing the API Key creation modal from the Atlas UI](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2022_01_13_at_2_01_55_PM_94e1f63e02.png)

Now fill in the `CLUSTER_NAME` with the name of your cluster. If you've used the default values when creating the cluster, it should be *Cluster0*. For `DATABASE` and `COLLECTION`, you can use an existing database if you have one ready. If the database and collection you specify do not exist, they will be created upon inserting the first document. 

Once you've filled in those variables, click on _Save_ to persist your data in Postman.

## Using the Data API
You are now ready to use the Data API from your Postman collection. 

### Insert a document
Start with the first request in the collection, the one called "Insert Document." 

Start by selecting the request from the left menu. If you click on the _Body_ tab, you will see what will be sent to the Data API.

```json
{
     "dataSource": "{{CLUSTER_NAME}}",
     "database": "{{DATABASE}}",
     "collection": "{{COLLECTION}}",
     "document": {
       "name": "John Sample",
       "age": 42
     }
 }
```

Here, you can see that we are using the workspace variables for the cluster, database, and collection names. The `document` property contains the document we want to insert into the collection.

Now hit the blue _Send_ button to trigger the request. In the bottom part of the screen, you will see the response from the server. You should see something similar to:

```json
{"insertedId":"61e07acf63093e54f3c6098c"}
```

This `insertedId` is the _id_ value of the newly created document. If you go to the Atlas UI, you will see the newly created document in the collection in the data explorer. Since you already have access to the Data API, why not use the API to see the inserted value?

### Find a document
Select the following request in the list, the one called "Find Document." Again, you can look at the body of the request by selecting the matching tab. In addition to the cluster, database, and collection names, you will see a `filter` property.

```json
{
     "dataSource": "{{CLUSTER_NAME}}",
     "database": "{{DATABASE}}",
     "collection": "{{COLLECTION}}",
     "filter": { "name": "John Sample" }
 }
```

The filter is the criteria that will be used for the query. In this case, you are searching for a person named "John Sample."

Click the Send button again to trigger the request. This time, you should see the document itself.

```json
{"document":{"_id":"61e07acf63093e54f3c6098c","name":"John Sample","age":42}}
```

You can use any [MongoDB query operators](https://docs.mongodb.com/manual/reference/operator/query/) to filter the records you want. For example, if you wanted the first document for a person older than 40, you could use the $gt operator.

```json
{
    "dataSource": "{{CLUSTER_NAME}}",
    "database": "{{DATABASE}}",
    "collection": "{{COLLECTION}}",
    "filter": { "age": {"$gt": 40} }
}
```
 
This last query should return you the same document again.
### Update a document
Say you made a typo when you entered John's information. He is not 42 years old, but rather 24. You can use the Data API to perform an update. Select the "Update Document" request from the list on the left, and click on the _Body_ tab. You will see the body for an update request. 

```json
{
     "dataSource": "{{CLUSTER_NAME}}",
     "database": "{{DATABASE}}",
     "collection": "{{COLLECTION}}",
     "filter": { "name": "John Sample" },
     "update": { "$set": { "age": 24 } }
 }
```

In this case, you can see a `filter` to find a document for a person with the name John Sample. The `update` field specifies what to update. You can use any [update operator](https://docs.mongodb.com/manual/reference/operator/update-field/) here. We've used `$set` for this specific example to change the value of the age field to `24`. Running this query should give you the following result.

```json
{"matchedCount":1,"modifiedCount":1}
```

This response tells us that the operation succeeded and that one document has been modified. If you go back to the "Find Document" request and run it for a person older than 40 again, this time, you should get the following response.

```json
{"document":null}
```

The `null` value is returned because no items match the criteria passed in the `filter` field.

### Delete a document
The process to delete a document is very similar. Select the "Delete Document" request from the left navigation bar, and click on the _Body_ tab to see the request's body.

```json
{
     "dataSource": "{{CLUSTER_NAME}}",
     "database": "{{DATABASE}}",
     "collection": "{{COLLECTION}}",
     "filter": { "name": "John Sample" }
 }
```

Just as in the "Find Document" endpoint, there is a filter field to select the document to delete. If you click on Send, this request will delete the person with the name "John Sample" from the collection. The response from the server is:

```json
{"deletedCount":1}
```

So you can see how many matching records were deleted from the database.

### Operations on multiple documents
So far, we have done each operation on single documents. The endpoints `/insertOne`, `/findOne`, `/updateOne`, and `/deleteOne` were used for that purpose. Each endpoint has a matching endpoint to perform operations on multiple documents in your collection.

You can find examples, along with the usage instructions for each endpoint, in the Postman collection. 

Some of those endpoints can be very helpful. The `/find` endpoint can return all the documents in a collection, which can be helpful for importing data into another database. You can also use the `/insertMany` endpoint to import large chunks of data into your collections.

However, use extreme care with `/updateMany` and `/deleteMany` since a small error could potentially destroy all the data in your collection.

### Aggregation Pipelines
One of the most powerful features of MongoDB is the ability to create [aggregation pipelines](https://docs.mongodb.com/manual/core/aggregation-pipeline/). These pipelines let you create complex queries using an array of JSON objects. You can also perform those queries on your collection with the Data API.

In the left menu, pick the "Run Aggregation Pipeline" item. You can use this request for running those pipelines. In the _Body_ tab, you should see the following JSON object.

```json
{
     "dataSource": "{{CLUSTER_NAME}}",
     "database": "{{DATABASE}}",
     "collection": "{{COLLECTION}}",
     "pipeline": [
         {
             "$sort": { "age": 1 }
         },
         {
             "$limit": 1
         }
     ]
 }
```

Here, we have a pipeline that will take all of the objects in the collection, sort them by ascending age using the `$sort` stage, and only return the first return using the `$limit` stage. This pipeline will return the youngest person in the collection. 

If you want to test it out, you can first run the "Insert Multiple Documents" request to populate the collection with multiple records.

## Summary
There you have it! A fast and easy way to test out the Data API or explore your MongoDB Atlas data using Postman. If you want to learn more about the Data API, check out the [Atlas Data API Introduction](https://www.mongodb.com/developer/quickstart/atlas_data_api_introduction/) blog post. If you are more interested in automating operations on your Atlas cluster, there is another API called the Management API. You can learn more about the latter on the [Automate Automation on MongoDB Atlas](https://www.mongodb.com/developer/article/automate-automation-mongodb-atlas/) blog post.


MongoDB's new Data API is a great way to access your MongoDB Atlas data using a REST-like interface. In this article, we will show you how to use Postman to read and write to your MongoDB Atlas cluster.

Accessing Atlas Data in Postman with the Data API

Maxime Beugnet

## TL;DR

You can retrieve an access token using the API like so:

``` bash
curl -X POST 'https://realm.mongodb.com/api/client/v2.0/app/covid-19-qppza/auth/providers/anon-user/login'
```

Then you can read the [GraphQL API documentation](https://covid-19-qppza.mongodbstitch.com/) and start running queries like this one using the access token you just retrieved:

``` bash
curl 'https://realm.mongodb.com/api/client/v2.0/app/covid-19-qppza/graphql' \
     --header 'Authorization: Bearer ACCESS_TOKEN' \
     --header 'Content-Type: application/json' \
     --data-raw '{"query":"query {countries_summary {_id combined_names confirmed country country_codes country_iso2s country_iso3s date deaths population recovered states uids}}"}'
```

## Introduction

Recently, we built the [MongoDB COVID-19 Open Data project](/article/johns-hopkins-university-covid-19-data-atlas) using the [dataset from Johns Hopkins University](https://github.com/CSSEGISandData/COVID-19/) (JHU).

It's a great dataset for education purposes and for pet projects. The MongoDB Atlas cluster is freely accessible using the user `readonly` and the password `readonly` using the connection string:

``` none
mongodb+srv://readonly:readonly@covid-19.hip2i.mongodb.net/covid19
```

>
>
>This cluster contains 2 databases: `covid19` and `covid19jhu`. Only the first one will be exposed with this GraphQL API. The second one contains the unprocessed raw data from JHU's CSV files. Learn about the databases and collection in [the dedicated blog post](/article/johns-hopkins-university-covid-19-data-atlas).
>
>

You can use this cluster to build your application, but I also set up a GraphQL API using [MongoDB Realm](https://www.mongodb.com/realm) to expose this data for you.

In this blog post, I will first show you how to access our GraphQL endpoint securely. Then we will have a look at the documentation together to build out a variety of GraphQL queries to access all sorts of information in our dataset - all against a single API endpoint.  Learning how to to use filters and request only specific fields in our data will help optimize the performance of your applications - by bringing you exactly the data you want - nothing more, nothing less.

<figure align="center">
    <img
        style="border-radius: 10px; width: 60%"
        src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/johns-hopkins-university-covid-19-graphql-api/trevor-wow.gif"
        alt="Trevor Noah saying wow gif"
    />
</figure>


## Prerequisites

-   Command line and [cURL](https://en.wikipedia.org/wiki/CURL) - which I'm using here for the sake of simplicity.
-   Or any other tool which handles HTTP queries. I also tested to run the following queries with [Postman](https://www.postman.com/), and it works great.


## COVID-19 GraphQL API


### Get an Access Token

I used [MongoDB Realm](https://www.mongodb.com/realm) to create this [GraphQL](https://graphql.org/) API. Since MongoDB Realm is secure by default, only authenticated queries can be made. Yet since I want to keep this service as open as possible, I simply used the [Anonymous Authentication](https://docs.mongodb.com/realm/authentication/anonymous/) offered by MongoDB Realm.

So now, all you need to retrieve an access token is the [MongoDB Realm Application ID](https://docs.mongodb.com/realm/get-started/find-your-app-id/) — or `APP_ID`, for short — of my MongoDB Realm application:

``` none
covid-19-qppza
```

And [the API to authenticate HTTP client request](https://docs.mongodb.com/realm/reference/authenticate-http-client-requests/), which is:

``` bash
curl -X POST 'https://realm.mongodb.com/api/client/v2.0/app/<APP_ID>/auth/providers/anon-user/login'
```

Inserting the `APP_ID` into the URL gives you:

``` bash
curl -X POST 'https://realm.mongodb.com/api/client/v2.0/app/covid-19-qppza/auth/providers/anon-user/login'
```

If you execute this query in your favorite shell, you will receive a JSON answer that looks like this one:

``` json
{
  "access_token":"eyJhbG......6dbnY",
  "refresh_token":"eyJhbG......uKpoM",
  "user_id":"5f692c44033b9e7f1554d475",
  "device_id":"000000000000000000000000"
}
```

Access tokens expire 30 minutes after MongoDB Realm grants them. When an access token expires, you can request a new one using the same API, or you can [get a new one using the refresh token](https://docs.mongodb.com/realm/reference/authenticate-http-client-requests/#refresh-a-client-api-access-token). Although it's often just easier to request a new one.

### Query the GraphQL API

Once you have the token, you can start browsing the [GraphQL API documentation](https://covid-19-qppza.mongodbstitch.com/) that I generated with [GraphDoc](https://github.com/2fd/graphdoc#readme) and build your first query.

Five collections are available in this GraphQL API, and you can learn more about each one of them [in our documentation](https://github.com/mongodb-developer/open-data-covid-19#databases-and-collections).  Each have a "singular" query which can be used to retrieve a single document and a "plural" one to retrieve a list of documents. As an exception, the metadata collection contains only a single document so it offers no "plural" query.

You can see all the possible queries in [the "query" page in the documentation](https://covid-19-qppza.mongodbstitch.com/query.doc.html), but I have also summarized them in the following table:

##### GraphQL API


<table style="
        border: 1px solid #B8C4C2;
        border-collapse: collapse;
        margin: 16px 0;
        table-layout: fixed;
">
    <thead style="border: inherit" valign="bottom">
        <tr style="border: inherit">
            <th style="width: 250px; border: inherit; padding: 10px">Collection</th>
            <th style="width: 250px; border: inherit; padding: 10px">Query (singular / plural)</th>
            <th style="width: 250px; border: inherit; padding: 10px">Fields available</th>
        </tr>
    </thead>
    <tbody style="border: inherit" valign="top">
        <tr style="border: inherit">
            <td style="border: inherit; padding: 10px">
                <a style="color: #f9fbfa;" href="https://github.com/mongodb-developer/open-data-covid-19#collection-metadata">metadata</a>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>metadatum</li>
                </ul>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>_id</li>
                    <li>countries</li>
                    <li>states</li>
                    <li>states_us</li>
                    <li>counties</li>
                    <li>iso3s</li>
                    <li>uids</li>
                    <li>first_date</li>
                    <li>last_date</li>
                </ul>
            </td>
        </tr>
        <tr style="border: inherit">
            <td style="border: inherit; padding: 10px">
                <a style="color: #f9fbfa;" href="https://github.com/mongodb-developer/open-data-covid-19#collection-countries_summary">countries_summary</a>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>countries_summary</li>
                    <li>countries_summarys</li>
                </ul>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>_id</li>
                    <li>combined_names</li>
                    <li>confirmed</li>
                    <li>country</li>
                    <li>country_codes</li>
                    <li>country_iso2s</li>
                    <li>country_iso3s</li>
                    <li>date</li>
                    <li>deaths</li>
                    <li>population</li>
                    <li>recovered</li>
                    <li>states</li>
                    <li>uids</li>
               </ul>
            </td>
        </tr>
        <tr style="border: inherit">
            <td style="border: inherit; padding: 10px">
                <a style="color: #f9fbfa;" href="https://github.com/mongodb-developer/open-data-covid-19#collection-global">global</a>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>global</li>
                    <li>globals</li>
                </ul>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>_id</li>
                    <li>combined_name</li>
                    <li>confirmed</li>
                    <li>country</li>
                    <li>country_code</li>
                    <li>country_iso2</li>
                    <li>country_iso3</li>
                    <li>date</li>
                    <li>deaths</li>
                    <li>loc { type coordinates }</li>
                    <li>population</li>
                    <li>recovered</li>
                    <li>state</li>
                    <li>uid</li>
               </ul>
            </td>
        </tr>
       <tr style="border: inherit">
            <td style="border: inherit; padding: 10px">
                <a style="color: #f9fbfa;" href="https://github.com/mongodb-developer/open-data-covid-19#collection-global">global</a>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>global</li>
                    <li>globals</li>
                </ul>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>_id</li>
                    <li>combined_name</li>
                    <li>confirmed</li>
                    <li>country</li>
                    <li>country_code</li>
                    <li>country_iso2</li>
                    <li>country_iso3</li>
                    <li>date</li>
                    <li>deaths</li>
                    <li>loc { type coordinates }</li>
                    <li>population</li>
                    <li>recovered</li>
                    <li>state</li>
                    <li>uid</li>
               </ul>
            </td>
        </tr>
       <tr style="border: inherit">
            <td style="border: inherit; padding: 10px">
                <a style="color: #f9fbfa;" href="https://github.com/mongodb-developer/open-data-covid-19#collection-global_and_us">global_and_us</a>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>global_and_u</li>
                    <li>global_and_us</li>
                </ul>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>_id</li>
                    <li>combined_name</li>
                    <li>confirmed</li>
                    <li>country</li>
                    <li>country_code</li>
                    <li>country_iso2</li>
                    <li>country_iso3</li>
                    <li>county</li>
                    <li>date</li>
                    <li>deaths</li>
                    <li>fips</li>
                    <li>loc { type coordinates }</li>
                    <li>population</li>
                    <li>recovered</li>
                    <li>uid</li>
               </ul>
            </td>
        </tr>
       <tr style="border: inherit">
            <td style="border: inherit; padding: 10px">
                <a style="color: #f9fbfa;" href="https://github.com/mongodb-developer/open-data-covid-19#collection-us_only">us_only</a>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>us_only</li>
                    <li>us_onlys</li>
                </ul>
            </td>
            <td style="border: inherit; padding: 10px">
                <ul>
                    <li>_id</li>
                    <li>combined_name</li>
                    <li>confirmed</li>
                    <li>country</li>
                    <li>country_code</li>
                    <li>country_iso2</li>
                    <li>country_iso3</li>
                    <li>county</li>
                    <li>date</li>
                    <li>deaths</li>
                    <li>fips</li>
                    <li>loc { type coordinates }</li>
                    <li>population</li>
                    <li>state</li>
                    <li>uid</li>
               </ul>
            </td>
        </tr>
    </tbody>
</table>

>
>
>Find all the details in the [GraphQL documentation](https://covid-19-qppza.mongodbstitch.com/query.doc.html).  To explore this data and the flexibility of GraphQL, let's build out three example queries.
>
>

#### Query 1. The Metadata Collection

Let's first query the [metadata collection](https://github.com/mongodb-developer/open-data-covid-19#collection-metadata).  This collection contains only one single document listing all the values (obtained with mongodb distinct function) for the major fields.

Here is the GraphQL query:

``` javascript
query {
  metadatum {
    _id
    countries
    states
    states_us
    counties
    iso3s
    uids
    first_date
    last_date
  }
}
```

Now let's build an HTTP query with it. Don't forget to replace the `ACCESS_TOKEN` in the query with your own valid token.

``` bash
curl 'https://realm.mongodb.com/api/client/v2.0/app/covid-19-qppza/graphql' \
     --header 'Authorization: Bearer ACCESS_TOKEN' \
     --header 'Content-Type: application/json' \
     --data-raw '{"query": "query { metadatum { _id countries states states_us counties iso3s uids first_date last_date } }" }'
```

This will answer a [JSON document](https://covid-19-qppza.mongodbstitch.com/metadatum.doc.html) which will help you populate your filters for the other queries:

``` json
{"data":
  {"metadatum":
    {
      "_id":"metadata",
      "countries": [ "Afghanistan", "Albania", "Algeria","..."],
      "states":["Alabama","Alaska","Alberta","American Samoa","..."],
      "states_us":["Alabama","Alaska","American Samoa","..."],
      "counties":["Abbeville","Acadia","Accomack","..."],
      "iso3s":["ABW","AFG","AGO","..."],
      "uids":[4,8,12,16,...],
      "first_date":"2020-01-22T00:00:00Z",
      "last_date":"2020-09-23T00:00:00Z"
    }
  }
}
```

#### Query 2. The `countries_summary` Collection

Now let's refine our data query even further. We want to see how France is trending for the last week, so we will use a query filter:

``` javascript
{country: "France", date_gte: "2020-09-16T00:00:00Z"}
```

Plus we will sort the dates in descending order with the most recent dates first. Remember with GraphQL, we can request as many or as few data fields as we want for the client. In this example, we'll only ask for the number of confirmed cases, deaths, and recoveries, along with the date. The final query with this filter and those specific fields is:

``` javascript
query {
  countries_summarys(query: {country: "France", date_gte: "2020-09-16T00:00:00Z"}, sortBy: DATE_DESC) {
    confirmed
    date
    deaths
    recovered
  }
}
```

Or with cURL:

``` bash
curl 'https://realm.mongodb.com/api/client/v2.0/app/covid-19-qppza/graphql' \
     --header 'Authorization: Bearer ACCESS_TOKEN' \
     --header 'Content-Type: application/json' \
     --data-raw '{"query": "query { countries_summarys(query: {country: \"France\", date_gte: \"2020-09-16T00:00:00Z\"}, sortBy: DATE_DESC) { confirmed date deaths recovered } }" }'
```

Which gives me:

``` json
{
    "data": {
        "countries_summarys": [
            {
                "confirmed": 507150,
                "date": "2020-09-22T00:00:00Z",
                "deaths": 31426,
                "recovered": 94961
            },
            {
                "confirmed": 496851,
                "date": "2020-09-21T00:00:00Z",
                "deaths": 31346,
                "recovered": 94289
            },
            {
                "confirmed": 467614,
                "date": "2020-09-20T00:00:00Z",
                "deaths": 31257,
                "recovered": 93586
            },
            {
                "confirmed": 467614,
                "date": "2020-09-19T00:00:00Z",
                "deaths": 31257,
                "recovered": 93586
            },
            {
                "confirmed": 467421,
                "date": "2020-09-18T00:00:00Z",
                "deaths": 31257,
                "recovered": 92700
            },
            {
                "confirmed": 454266,
                "date": "2020-09-17T00:00:00Z",
                "deaths": 31103,
                "recovered": 91765
            },
            {
                "confirmed": 443869,
                "date": "2020-09-16T00:00:00Z",
                "deaths": 31056,
                "recovered": 91293
            }
        ]
    }
}
```

#### Query 3. The `global_and_us` Collection

Finally, let's find the three counties in the USA with the greatest number of confirmed cases:

``` javascript
query {
  global_and_us(query: {country: "US", date: "2020-09-22T00:00:00Z"}, sortBy: CONFIRMED_DESC, limit: 3) {
    confirmed
    deaths
    state
    county
  }
}
```

Or with cURL:

``` bash
curl 'https://realm.mongodb.com/api/client/v2.0/app/covid-19-qppza/graphql' \
     --header 'Authorization: Bearer ACCESS_TOKEN' \
     --header 'Content-Type: application/json' \
     --data-raw '{"query": "query { global_and_us(query: {country: \"US\", date: \"2020-09-22T00:00:00Z\"}, sortBy: CONFIRMED_DESC, limit: 3) { confirmed deaths state county } }" }'
```

Results:

``` json
{
  "data": {
    "global_and_us": [
      {
        "confirmed": 262133,
        "county": "Los Angeles",
        "deaths": 6401,
        "state": "California"
      },
      {
        "confirmed": 167515,
        "county": "Miami-Dade",
        "deaths": 3085,
        "state": "Florida"
      },
      {
        "confirmed": 140314,
        "county": "Maricopa",
        "deaths": 3275,
        "state": "Arizona"
      }
    ]
  }
}
```

## But How Did I Build This GraphQL API?

Simple and easy, I used the [MongoDB Realm GraphQL API](https://docs.mongodb.com/realm/graphql/) which just took me a few clicks.

If you want to build this very same service using this dataset, check out [our blog](/article/johns-hopkins-university-covid-19-data-atlas) which explains the dataset's content and how you can grab it. Then, have a look at Nic's [blog post](/how-to/graphql-support-atlas-stitch) which explains how to set up a GraphQL API using MongoDB Realm.

You want to improve your knowledge even more around MongoDB and GraphQL?  Then you must read the blog post [GraphQL: The Easy Way to Do the Hard Stuff](/how-to/graphql-easy) from Karen and Brian.

## Wrap-Up

MongoDB made setting up a GraphQL API really easy. And this GraphQL API made querying our Covid19 dataset to gain insight even easier. We update this data every hour, and we hope you will enjoy using this data to explore and learn.

>
>
>Are you trying to help solve this pandemic in any way? Remember that if you are trying to build an application that helps to detect, understand, or stop the spread of the COVID-19 virus, we have a [FREE MongoDB Atlas credit program](https://www.mongodb.com/blog/post/helping-developers-tackle-covid19) that can help you scale and hopefully solve this global pandemic.
>
>

I truly hope you will be able to build something amazing with this GraphQL API. Even if it won't save the world from the COVID-19 pandemic, I hope it will be a great source of motivation and training for your next pet project.

[Send me a tweet](https://twitter.com/MBeugnet) or ping me in our [Community Forum](https://developer.mongodb.com/community/forums/) with your project using this API. I will definitely check it out!


Making the Johns Hopkins University COVID-19 Data open and accessible to all through a simple GraphQL API using MongoDB.

A Free GraphQL API for Johns Hopkins University COVID-19 Dataset

Andrew Morgan

The [Realm](https://www.realm.io) makes it much
faster to develop mobile applications. [Realm
Studio](https://github.com/realm/realm-studio) is a desktop app that
lets you view, manipulate, and import data held within your mobile app's
Realm database.

This article steps through how to track down the locations of your iOS
Realm database files, open them in Realm Studio, view the data, and make
changes. If you're developing an Android app, then finding the Realm
database files will be a little different (we'll follow up with an
Android version later), but if you can figure out how to locate the
Realm file, then the instructions on using Realm Studio should work.

## Prerequisites

If you want to build and run the app for yourself, this is what you'll
need:

-   A Mac.
-   Xcode – any reasonably recent version will work.
-   Realm Studio 10.1.0+ – earlier versions had an issue when working
    with Realms using [Atlas Device
    Sync](https://www.mongodb.com/app-services/device-sync).

I'll be using the data and schema from my existing
[RChat](https://github.com/ClusterDB/RChat) iOS app. You can use any
Realm-based app, but if you want to understand more about RChat, check
out [Building a Mobile Chat App Using Realm – Data Architecture](/how-to/realm-swiftui-ios-chat-app) and
[Building a Mobile Chat App Using Realm – Integrating Realm into Your App](/how-to/building-a-mobile-chat-app-using-realm).

## Walkthrough

This walkthrough shows you how to:

- [Install & Run Realm Studio](#install---run-realm-studio)
- [Track Down Realm Data Files – Xcode Simulator](#track-down-realm-data-files---xcode-simulator)
- [Track Down Realm Data Files – Real iOS Devices](#track-down-realm-data-files---real-ios-devices)
- [View Realm Data](#view-realm-data)
- [Add, Modify, and Delete Data](#add--modify--and-delete-data)

### Install & Run Realm Studio

I'm using [Realm Studio
10.1.1](https://studio-releases.realm.io/v10.1.1) to create this
article. If you have 10.1.0 installed, then that should work too.

If you don't already have Realm Studio 10.1.0+ installed, then [download
it here](https://studio-releases.realm.io/) and install.

That's it.

But, when you open the app, you're greeted by this:

![Realm Studio Splash Screen](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/Realm-Studio-Splash-Screen.png)

There's a single button letting me "Open Realm file," and when I click
on it, I get a file explorer where I can browse my laptop's file system.

Where am I supposed to find my Realm file? I cover that in the next
section.

### Track Down Realm Data Files – Xcode Simulator

If you're running your app in one of Xcode's simulators, then the Realm
files are stored in your Mac's file system. They're typically somewhere
along the lines of
`~/Library/Developer/CoreSimulator/Devices/???????/data/Containers/Data/Application/???????/Documents/mongodb-realm/???????/????????/???????.realm`.

The scientific way to find the file's location is to add some extra code
to your app or to use a breakpoint.

While my app's in development, I'll normally print the location of a
Realm's file whenever I open it. Don't worry if you're not explicitly
opening your Realm(s) in your code (e.g., if you're using the default
realm) as I'll cover the file search approach soon. This is the code to
add to your app once you've opened your realm – `realm`:

``` swift
print("User Realm User file location: \(realm.configuration.fileURL!.path)")
```

If you don't want to edit the code, then an Xcode breakpoint delivers
the same result:

![XCode breakpoint to find realm file](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/xcode-breakpoint-to-find-realm-file.png)

Once you have the file location, open it in Realm Studio from the
terminal:

``` bash
open /Users/andrew.morgan/Library/Developer/CoreSimulator/Devices/E7526AFE-E886-490A-8085-349C8E8EDC5B/data/Containers/Data/Application/C3ADE2F2-ABF0-4BD0-9F47-F21894E850DB/Documents/mongodb-realm/rchat-saxgm/60099aefb33c57e9a9828d23/%22user%3D60099aefb33c57e9a9828d23%22.realm
```

Less scientific but simpler is to take advantage of the fact that the
data files will always be of type `realm` and located somewhere under
`~/Library/Developer/CoreSimulator/Devices`. Open Finder in that folder:
`open ~/Library/Developer/CoreSimulator/Devices` and then create a
"saved search" so that you can always find all of your realm files.
You'll most often be looking for the most recent one.

![Create saved search](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/Create-Saved-Search.gif)

The nice thing about this approach is that you only need to create the
search once. Then click on "Realms," find the file you need, and then
double-click it to open it in Realm Studio.

### Track Down Realm Data Files – Real iOS Devices

Unfortunately, you can't use Realm Studio to interact with live Realm
files on a real iOS device.

What we can do is download a copy of your app's Realm files from your
iOS device to your laptop. You need to connect your iOS device to your
Mac, agree to trust the computer, etc.

Once connected, you can use Xcode to download a copy of the "Container"
for your app. Open the Xcode device manager—"Window/Devices and
Simulators." Find your device and app, then download the container:

![Download iOS app container](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/Download-iOS-app-container.gif)

Note that you can only access the containers for apps that you've built
and installed through Xcode, not ones you've installed through the App
Store.

Right-click the downloaded file and "Show Package Contents." You'll find
your Realm files under
`AppData/Documents/mongodb-realm/<app-name>/?????`. Find the file for
the realm you're interested in and double-click it to open it in Realm
Studio.

### View Realm Data

After opening a Realm file, Realm Studio will show a window with all of
the top-level Realm Object classes in use by your app. In this example,
the realm I've opened only contains instances of the `Chatster` class.
There's a row for each `Chatster` Object that I'd created through the
app:

![Top level chatster view](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/top-level-chatster-view.png)

If there are a lot of objects, then you can filter them using a simple
[query
syntax](https://docs.mongodb.com/realm-legacy/docs/javascript/latest/api/tutorial-query-language.html):

![Janey search](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/Janey-search.png)

If the Realm Object class contains a `List` or an `EmbeddedObject`, then
they will show as blue links—in this example, `conversations` and
`userPreferences` are a list of `Conversation` objects and an embedded
`UserPreferences` object respectively:

![User object](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/user-object.png)

Clicking on one of the `UserPreferences` links brings up the contents of
the embedded object:

![User preferences object](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/user-preferences-object.png)

### Add, Modify, and Delete Data

The ability to view your Realm data is invaluable for understanding
what's going on inside your app.

Realm Studio takes it a step further by letting you add, modify, and
delete data. This ability helps to debug and test your app.

As a first example, I click on "Create ChatMessage" to add a new message
to a conversation:

![Create chat message button](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/create-chatmessage-button.png)

Fill out the form and click "Create" to add the new `ChatMessage`
object:

![Create new message](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/create-new-message.png)

We can then observe the effect of that change in our app:

![Add message](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/add-message.gif)

I could have tested that change using the app, but there are different
things that I can try using Realm Studio.

I haven't yet included the ability to delete or edit existing messages,
but I can now at least test that this view can cope when the data
changes:

![Modify chat objects](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/how-to/realm-studio/modify-chat-objects.gif)

## Summary

In this article, we've seen how to find and open your iOS Realm data
files in Realm Studio. We've viewed the data and then made changes and
observed the iOS app reacting to those changes.

Realm Studio has several other useful features that I haven't covered
here. As it's a GUI, it's fairly easy to figure out how to use them, and
the [docs](https://docs.realm.io/sync/realm-studio) are available if you
get stuck. These functions include:

-   Import data into Realm from a CSV file.
-   Export your Realm data as a JSON file.
-   Edit the schema.
-   Open the Realm file from an app and export the schema in a different
    language. We used this for the [WildAid O-FISH
    project](https://github.com/wildaid). I created the schema in the
    iOS app, and another developer exported a Kotlin version of the
    schema from Realm Studio to use in the Android app.

## References

-   [GitHub Repo for RChat App](https://github.com/ClusterDB/RChat).
-   Read [Building a Mobile Chat App Using Realm – Data Architecture](/how-to/realm-swiftui-ios-chat-app) to understand the data model and partitioning strategy behind the RChat app.
-   Read [Building a Mobile Chat App Using Realm – Integrating Realm into Your App](/how-to/building-a-mobile-chat-app-using-realm) to learn how to create the RChat app.
-   If you're building your first SwiftUI/Realm app, then check out [Build Your First iOS Mobile App Using Realm, SwiftUI, & Combine](/how-to/realm-swiftui-combine-first-app).
-   [GitHub Repo for Realm-Cocoa SDK](https://github.com/realm/realm-cocoa).
-   [Realm Cocoa SDK documentation](https://realm.io/docs/swift/latest/).
-   [MongoDB's Realm documentation](https://docs.mongodb.com/realm/).

>
>
>If you have questions, please head to our [developer community
>website](https://community.mongodb.com/) where the MongoDB engineers and
>the MongoDB community will help you build your next big idea with
>MongoDB.
>
>


Discover how to access and manipulate your iOS App's Realm data using the Realm Studio GUI.

Postman API

All Postman API Content

Accessing Atlas Data in Postman with the Data API

A Free GraphQL API for Johns Hopkins University COVID-19 Dataset

Accessing Realm Data on iOS Using Realm Studio

Automate the Automation on MongoDB Atlas

Related Topics