You can use our NerdGraph API to make NRQL queries.

Overview of querying with NerdGraph

You can run NRQL queries in our query builder or with NerdGraph. NerdGraph gives you the ability to do some things you can't do from the UI, such as query across multiple accounts, and run asynchronous queries.

Requirements

All user types can query data for the accounts they have access to. If you can't query via NerdGraph, it may be because you're lacking access to that account.
All NRQL queries are subject to NRQL query limits

Basic NRQL queries with NerdGraph

To make basic NRQL queries using NerdGraph:

Go to the NerdGraph explorer.
Pass the NRQL query as a string argument to the NRQL object, and include the results field in your NerdGraph query.

For example, to get a count of all transaction events in the last hour, use the following query:

{
   actor {
      account(id: YOUR_ACCOUNT_ID) {
         nrql(query: "SELECT count(*) FROM Transaction SINCE 1 HOUR AGO") {
            results
         }
      }
   }
}

This query example would return a result like this:

{
   "data": {
      "actor": {
         "account": {
            "nrql": {
               "results": [
                 {
                  "count": 1000
                 }
                ]
            }
         }
      }
   }
}

Cross-account queries

With NerdGraph, you can run a query across more than one account, which you can't do in the query builder. You'll need the account IDs for the accounts you want to query.

Here's an example of running a cross-account NRQL query:

{
  actor {
    nrql(
      accounts: [ACCOUNT_ID_1, ACCOUNT_ID_2, ACCOUNT_ID_3]
      options: {}
      query: "NRQL_QUERY"
      timeout: 70
    ) {
      results
    }
  }
}

For how to create a dashboard with data from multiple accounts, see the NerdGraph dashboard tutorial.

Create embeddable charts

In addition to returning raw data, you can fetch embeddable chart links for the data to use in an application. For example, instead of a single count of transaction, you can create a chart that illustrates a timeseries of bucketed counts over time. Add TIMESERIES to your query with embeddedChartUrl:

{
   actor {
      account(id: YOUR_ACCOUNT_ID) {
         nrql(query: "SELECT count(*) from Transaction TIMESERIES") {
            embeddedChartUrl
         }
      }
   }
}

This NerdGraph query example returns the URL for the chart in the following response:

{
   "data": {
      "actor": {
         "account": {
            "nrql": {
               "embeddedChartUrl": "https://chart-embed.service.newrelic.com/charts/EMBEDDABLE-CHART-ID"
            }
         }
      }
   }
}

If you view the embedded chart URL using any standard HTTP client, it returns an image showing a visualization of the response to the query you submitted. These charts follow the same embedded chart rules as embedded charts that are created elsewhere. To change the style of the data visualization, pass a chartType argument to embeddedChartUrl.

When using NerdGraph to explore your data, you can use the suggestedFacets field to return suggested attributes for use in faceted NRQL queries.

Here are some of the rules that govern what attributes are suggested:

Built-in suggestions. Each event type comes with its own set of recommended attributes. These are attributes chosen by New Relic for their importance and popularity.
Usage-based suggestions. Some attribute suggestions are based on the queries that have been frequently used by your account. These suggestions can include custom attributes.
Role restriction. Restricted users do not have access to account-related facet suggestions.
To disable the use of account data for determining suggested queries, contact Support.

Here's an example of returning suggested attributes for faceting transaction counts. The response suggests the host attribute. Faceting by host can reveal that one host is servicing more requests than other hosts.

{
   actor {
      account(id: YOUR_ACCOUNT_ID) {
         nrql(query: "SELECT count(*) from Transaction TIMESERIES") {
            suggestedFacets {
               attributes
            }
         }
      }
   }
}

This NerdGraph query example returns a response similar to this:

{
   "data": {
      "actor": {
         "account": {
            "nrql": {
               "suggestedFacets": [
                  "attributes": ["host"]
               ]
            }
         }
      }
   }
}

Longer-running queries

If you need to run longer-running NRQL queries, see Asynchronous queries.

Other querying options

NerdGraph gives you other querying options, such as:

NerdGraph tutorial: Query your data using NRQL