# Aggregate conversation data with Conversation Insights

In this guide, you'll use [Conversation Insights](/docs/conversations/intelligence/conversation-insights) to discover available data and aggregate your conversation metrics.

## Prerequisites

Complete the prerequisites:

* [Create a Twilio account](https://www.twilio.com/try-twilio).
* [Store your Twilio credentials in environment variables](/docs/usage/secure-credentials).
* [Set up Conversation Orchestrator](/docs/conversations/orchestrator/quickstart) with at least one conversation.

> \[!NOTE]
>
> Insights data becomes available approximately 15 minutes after conversation events.

## Discover available data

Before querying, use the Metadata API to see what measures and dimensions are available.

Send a `GET` request to the Metadata endpoint:

Retrieve available measures and dimensions

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function fetchMetadata() {
  const metadata = await client.insights.v3.metadata.fetch();

  console.log(metadata.domain);
}

fetchMetadata();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

metadata = client.insights.v3.metadata.fetch()

print(metadata.domain)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Insights.V3;
using System.Threading.Tasks;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var metadata = await MetadataResource.FetchAsync();

        Console.WriteLine(metadata.Domain);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import com.twilio.Twilio;
import com.twilio.rest.insights.v3.Metadata;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
        Metadata.FetchMetadataResponse response = Metadata.fetcher().fetch();

        System.out.println(response.getDomain());
    }
}
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

metadata = @client
           .insights
           .v3
           .metadata
           .fetch

puts metadata.domain
```

```bash
curl -X GET "https://insights.twilio.com/v3/InsightsDomains/Conversations/Metadata" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

The response includes a list of cubes, each with its available measures and dimensions.

```json
{
  "domain": "Conversations",
  "cubes": [
    {
      "name": "Conversation",
      "description": "Contains aggregated conversation event data",
      "measures": [
        {
          "name": "Conversation.Count",
          "type": "number",
          "aggregation": "countDistinct",
          "description": "The count of unique conversations"
        }
      ],
      "dimensions": [
        {
          "name": "Conversation.ConversationId",
          "type": "string",
          "description": "The unique identifier for the conversation"
        }
      ]
    }
  ]
}
```

## Aggregate total conversation count

To get the total conversation count, make a `POST` request to the Query endpoint.

Query total conversation count

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createQueryResults() {
  const query = await client.insights.v3.query.create({
    domain: "Conversations",
    query: {
      measures: ["Conversation.Count"],
      filters: [
        {
          expressions: [
            {
              op: "GT",
              field: "Conversation.CreatedDate",
              values: ["2026-04-02"],
            },
          ],
        },
      ],
    },
  });

  console.log(query.domain);
}

createQueryResults();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
from twilio.rest.insights.v3 import QueryList

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

query = client.insights.v3.query.create(
    insights_query_request=QueryList.InsightsQueryRequest(
        {
            "domain": "Conversations",
            "query": QueryList.QueryDefinition(
                {
                    "measures": ["Conversation.Count"],
                    "filters": [
                        QueryList.QueryDefinitionFilters(
                            {
                                "expressions": [
                                    QueryList.QueryDefinitionFiltersExpressions(
                                        {
                                            "op": "GT",
                                            "field": "Conversation.CreatedDate",
                                            "values": ["2026-04-02"],
                                        }
                                    )
                                ]
                            }
                        )
                    ],
                }
            ),
        }
    )
)

print(query.domain)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Insights.V3;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var query = await QueryResource.CreateAsync(
            insightsQueryRequest: new QueryResource.InsightsQueryRequest.Builder()
                .WithDomain("Conversations")
                .WithQuery(
                    new QueryResource.QueryDefinition.Builder()
                        .WithMeasures(new List<string> { "Conversation.Count" })
                        .WithFilters(new List<QueryResource.QueryDefinitionFilters> {
                            new QueryResource.QueryDefinitionFilters.Builder()
                                .WithExpressions(
                                    new List<QueryResource.QueryDefinitionFiltersExpressions> {
                                        new QueryResource.QueryDefinitionFiltersExpressions
                                            .Builder()
                                            .WithOp("GT")
                                            .WithField("Conversation.CreatedDate")
                                            .WithValues(new List<string> { "2026-04-02" })
                                            .Build()
                                    })
                                .Build()
                        })
                        .Build())
                .Build());

        Console.WriteLine(query.Domain);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import com.twilio.Twilio;
import com.twilio.rest.insights.v3.Query;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

        Query.QueryDefinitionFiltersExpressions queryDefinitionFiltersExpressions1 =
            Query.QueryDefinitionFiltersExpressions.builder(Query.Op.GT, "Conversation.CreatedDate")
                .values(Arrays.asList("2026-04-02"))
                .build();

        Query.QueryDefinitionFilters queryDefinitionFilters1 =
            Query.QueryDefinitionFilters.builder(Arrays.asList(queryDefinitionFiltersExpressions1)).build();

        Query.QueryDefinition queryDefinition = Query.QueryDefinition.builder()
                                                    .measures(Arrays.asList("Conversation.Count"))
                                                    .filters(Arrays.asList(queryDefinitionFilters1))
                                                    .build();

        Query.InsightsQueryRequest insightsQueryRequest =
            Query.InsightsQueryRequest.builder(queryDefinition).domain("Conversations").build();

        Query.CreateQueryResponse response = Query.creator(insightsQueryRequest).create();

        System.out.println(response.getDomain());
    }
}
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

query = @client
        .insights
        .v3
        .query
        .create(
          insights_query_request: {
            'domain' => 'Conversations',
            'query' => {
              'measures' => [
                'Conversation.Count'
              ],
              'filters' => [
                {
                  'expressions' => [
                    {
                      'op' => 'GT',
                      'field' => 'Conversation.CreatedDate',
                      'values' => [
                        '2026-04-02'
                      ]
                    }
                  ]
                }
              ]
            }
          }
        )

puts query.domain
```

```bash
INSIGHTS_QUERY_REQUEST_OBJ=$(cat << EOF
{
  "domain": "Conversations",
  "query": {
    "measures": [
      "Conversation.Count"
    ],
    "filters": [
      {
        "expressions": [
          {
            "op": "GT",
            "field": "Conversation.CreatedDate",
            "values": [
              "2026-04-02"
            ]
          }
        ]
      }
    ]
  }
}
EOF
)
curl -X POST "https://insights.twilio.com/v3/InsightsDomains/Conversations/Query" \
--json "$INSIGHTS_QUERY_REQUEST_OBJ" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

The response includes your aggregated data:

```json
{
  "domain": "Conversations",
  "items": [
    {
      "Conversation.Count": "2"
    }
  ],
  "meta": {
    "key": "items",
    "nextToken": null,
    "pageSize": 50,
    "previousToken": null
  }
}
```

## Add dimensions

Query conversations grouped by dimensions. This example counts conversations by status:

Query conversation count by status

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createQueryResults() {
  const query = await client.insights.v3.query.create({
    domain: "Conversations",
    query: {
      measures: ["Conversation.Count"],
      dimensions: ["Conversation.ConversationStatus"],
      filters: [
        {
          expressions: [
            {
              op: "GT",
              field: "Conversation.CreatedDate",
              values: ["2026-04-02"],
            },
          ],
        },
      ],
    },
  });

  console.log(query.domain);
}

createQueryResults();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
from twilio.rest.insights.v3 import QueryList

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

query = client.insights.v3.query.create(
    insights_query_request=QueryList.InsightsQueryRequest(
        {
            "domain": "Conversations",
            "query": QueryList.QueryDefinition(
                {
                    "measures": ["Conversation.Count"],
                    "dimensions": ["Conversation.ConversationStatus"],
                    "filters": [
                        QueryList.QueryDefinitionFilters(
                            {
                                "expressions": [
                                    QueryList.QueryDefinitionFiltersExpressions(
                                        {
                                            "op": "GT",
                                            "field": "Conversation.CreatedDate",
                                            "values": ["2026-04-02"],
                                        }
                                    )
                                ]
                            }
                        )
                    ],
                }
            ),
        }
    )
)

print(query.domain)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Insights.V3;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var query = await QueryResource.CreateAsync(
            insightsQueryRequest: new QueryResource.InsightsQueryRequest.Builder()
                .WithDomain("Conversations")
                .WithQuery(
                    new QueryResource.QueryDefinition.Builder()
                        .WithMeasures(new List<string> { "Conversation.Count" })
                        .WithDimensions(new List<string> { "Conversation.ConversationStatus" })
                        .WithFilters(new List<QueryResource.QueryDefinitionFilters> {
                            new QueryResource.QueryDefinitionFilters.Builder()
                                .WithExpressions(
                                    new List<QueryResource.QueryDefinitionFiltersExpressions> {
                                        new QueryResource.QueryDefinitionFiltersExpressions
                                            .Builder()
                                            .WithOp("GT")
                                            .WithField("Conversation.CreatedDate")
                                            .WithValues(new List<string> { "2026-04-02" })
                                            .Build()
                                    })
                                .Build()
                        })
                        .Build())
                .Build());

        Console.WriteLine(query.Domain);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import com.twilio.Twilio;
import com.twilio.rest.insights.v3.Query;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

        Query.QueryDefinitionFiltersExpressions queryDefinitionFiltersExpressions1 =
            Query.QueryDefinitionFiltersExpressions.builder(Query.Op.GT, "Conversation.CreatedDate")
                .values(Arrays.asList("2026-04-02"))
                .build();

        Query.QueryDefinitionFilters queryDefinitionFilters1 =
            Query.QueryDefinitionFilters.builder(Arrays.asList(queryDefinitionFiltersExpressions1)).build();

        Query.QueryDefinition queryDefinition = Query.QueryDefinition.builder()
                                                    .measures(Arrays.asList("Conversation.Count"))
                                                    .dimensions(Arrays.asList("Conversation.ConversationStatus"))
                                                    .filters(Arrays.asList(queryDefinitionFilters1))
                                                    .build();

        Query.InsightsQueryRequest insightsQueryRequest =
            Query.InsightsQueryRequest.builder(queryDefinition).domain("Conversations").build();

        Query.CreateQueryResponse response = Query.creator(insightsQueryRequest).create();

        System.out.println(response.getDomain());
    }
}
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

query = @client
        .insights
        .v3
        .query
        .create(
          insights_query_request: {
            'domain' => 'Conversations',
            'query' => {
              'measures' => [
                'Conversation.Count'
              ],
              'dimensions' => [
                'Conversation.ConversationStatus'
              ],
              'filters' => [
                {
                  'expressions' => [
                    {
                      'op' => 'GT',
                      'field' => 'Conversation.CreatedDate',
                      'values' => [
                        '2026-04-02'
                      ]
                    }
                  ]
                }
              ]
            }
          }
        )

puts query.domain
```

```bash
INSIGHTS_QUERY_REQUEST_OBJ=$(cat << EOF
{
  "domain": "Conversations",
  "query": {
    "measures": [
      "Conversation.Count"
    ],
    "dimensions": [
      "Conversation.ConversationStatus"
    ],
    "filters": [
      {
        "expressions": [
          {
            "op": "GT",
            "field": "Conversation.CreatedDate",
            "values": [
              "2026-04-02"
            ]
          }
        ]
      }
    ]
  }
}
EOF
)
curl -X POST "https://insights.twilio.com/v3/InsightsDomains/Conversations/Query" \
--json "$INSIGHTS_QUERY_REQUEST_OBJ" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

The response groups results by status:

```json
{
  "domain": "Conversations",
  "items": [
    {
      "Conversation.ConversationStatus": "ACTIVE",
      "Conversation.Count": "15"
    }
  ],
  "meta": {
    "key": "items",
    "nextToken": null,
    "pageSize": 50,
    "previousToken": null
  }
}
```

## Count operator results

Query operator results to analyze intelligence operators run on your conversations. This example counts operator results grouped by operator name:

Query operator result count by operator name

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createQueryResults() {
  const query = await client.insights.v3.query.create({
    domain: "Conversations",
    query: {
      measures: ["OperatorResult.Count"],
      dimensions: ["OperatorResult.OperatorName"],
      filters: [
        {
          expressions: [
            {
              op: "GT",
              field: "OperatorResult.CreatedDate",
              values: ["2026-04-02"],
            },
          ],
        },
      ],
    },
  });

  console.log(query.domain);
}

createQueryResults();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
from twilio.rest.insights.v3 import QueryList

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

query = client.insights.v3.query.create(
    insights_query_request=QueryList.InsightsQueryRequest(
        {
            "domain": "Conversations",
            "query": QueryList.QueryDefinition(
                {
                    "measures": ["OperatorResult.Count"],
                    "dimensions": ["OperatorResult.OperatorName"],
                    "filters": [
                        QueryList.QueryDefinitionFilters(
                            {
                                "expressions": [
                                    QueryList.QueryDefinitionFiltersExpressions(
                                        {
                                            "op": "GT",
                                            "field": "OperatorResult.CreatedDate",
                                            "values": ["2026-04-02"],
                                        }
                                    )
                                ]
                            }
                        )
                    ],
                }
            ),
        }
    )
)

print(query.domain)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Insights.V3;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var query = await QueryResource.CreateAsync(
            insightsQueryRequest: new QueryResource.InsightsQueryRequest.Builder()
                .WithDomain("Conversations")
                .WithQuery(
                    new QueryResource.QueryDefinition.Builder()
                        .WithMeasures(new List<string> { "OperatorResult.Count" })
                        .WithDimensions(new List<string> { "OperatorResult.OperatorName" })
                        .WithFilters(new List<QueryResource.QueryDefinitionFilters> {
                            new QueryResource.QueryDefinitionFilters.Builder()
                                .WithExpressions(
                                    new List<QueryResource.QueryDefinitionFiltersExpressions> {
                                        new QueryResource.QueryDefinitionFiltersExpressions
                                            .Builder()
                                            .WithOp("GT")
                                            .WithField("OperatorResult.CreatedDate")
                                            .WithValues(new List<string> { "2026-04-02" })
                                            .Build()
                                    })
                                .Build()
                        })
                        .Build())
                .Build());

        Console.WriteLine(query.Domain);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import com.twilio.Twilio;
import com.twilio.rest.insights.v3.Query;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

        Query.QueryDefinitionFiltersExpressions queryDefinitionFiltersExpressions1 =
            Query.QueryDefinitionFiltersExpressions.builder(Query.Op.GT, "OperatorResult.CreatedDate")
                .values(Arrays.asList("2026-04-02"))
                .build();

        Query.QueryDefinitionFilters queryDefinitionFilters1 =
            Query.QueryDefinitionFilters.builder(Arrays.asList(queryDefinitionFiltersExpressions1)).build();

        Query.QueryDefinition queryDefinition = Query.QueryDefinition.builder()
                                                    .measures(Arrays.asList("OperatorResult.Count"))
                                                    .dimensions(Arrays.asList("OperatorResult.OperatorName"))
                                                    .filters(Arrays.asList(queryDefinitionFilters1))
                                                    .build();

        Query.InsightsQueryRequest insightsQueryRequest =
            Query.InsightsQueryRequest.builder(queryDefinition).domain("Conversations").build();

        Query.CreateQueryResponse response = Query.creator(insightsQueryRequest).create();

        System.out.println(response.getDomain());
    }
}
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

query = @client
        .insights
        .v3
        .query
        .create(
          insights_query_request: {
            'domain' => 'Conversations',
            'query' => {
              'measures' => [
                'OperatorResult.Count'
              ],
              'dimensions' => [
                'OperatorResult.OperatorName'
              ],
              'filters' => [
                {
                  'expressions' => [
                    {
                      'op' => 'GT',
                      'field' => 'OperatorResult.CreatedDate',
                      'values' => [
                        '2026-04-02'
                      ]
                    }
                  ]
                }
              ]
            }
          }
        )

puts query.domain
```

```bash
INSIGHTS_QUERY_REQUEST_OBJ=$(cat << EOF
{
  "domain": "Conversations",
  "query": {
    "measures": [
      "OperatorResult.Count"
    ],
    "dimensions": [
      "OperatorResult.OperatorName"
    ],
    "filters": [
      {
        "expressions": [
          {
            "op": "GT",
            "field": "OperatorResult.CreatedDate",
            "values": [
              "2026-04-02"
            ]
          }
        ]
      }
    ]
  }
}
EOF
)
curl -X POST "https://insights.twilio.com/v3/InsightsDomains/Conversations/Query" \
--json "$INSIGHTS_QUERY_REQUEST_OBJ" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

The response groups results by operator name:

```json
{
  "domain": "Conversations",
  "items": [
    {
      "OperatorResult.Count": "168",
      "OperatorResult.OperatorName": "Sentiment"
    }
  ],
  "meta": {
    "key": "items",
    "nextToken": null,
    "pageSize": 1,
    "previousToken": null
  }
}
```

## Filter by Knowledge Base

Query operator results that used a specific [Knowledge Base](/docs/conversations/knowledge). This example retrieves conversations and operator names filtered by Knowledge Base ID:

Query operator results filtered by Knowledge Base ID

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createQueryResults() {
  const query = await client.insights.v3.query.create({
    domain: "Conversations",
    query: {
      dimensions: [
        "OperatorResult.ConversationId",
        "OperatorResult.OperatorName",
        "OperatorResult.KnowledgeBaseId",
      ],
      filters: [
        {
          op: "AND",
          expressions: [
            {
              op: "GT",
              field: "OperatorResult.CreatedDate",
              values: ["2026-04-10"],
            },
            {
              op: "EQ",
              field: "OperatorResult.KnowledgeBaseId",
              values: ["know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"],
            },
          ],
        },
      ],
    },
  });

  console.log(query.domain);
}

createQueryResults();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
from twilio.rest.insights.v3 import QueryList

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

query = client.insights.v3.query.create(
    insights_query_request=QueryList.InsightsQueryRequest(
        {
            "domain": "Conversations",
            "query": QueryList.QueryDefinition(
                {
                    "dimensions": [
                        "OperatorResult.ConversationId",
                        "OperatorResult.OperatorName",
                        "OperatorResult.KnowledgeBaseId",
                    ],
                    "filters": [
                        QueryList.QueryDefinitionFilters(
                            {
                                "op": "AND",
                                "expressions": [
                                    QueryList.QueryDefinitionFiltersExpressions(
                                        {
                                            "op": "GT",
                                            "field": "OperatorResult.CreatedDate",
                                            "values": ["2026-04-10"],
                                        }
                                    ),
                                    QueryList.QueryDefinitionFiltersExpressions(
                                        {
                                            "op": "EQ",
                                            "field": "OperatorResult.KnowledgeBaseId",
                                            "values": [
                                                "know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
                                            ],
                                        }
                                    ),
                                ],
                            }
                        )
                    ],
                }
            ),
        }
    )
)

print(query.domain)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Insights.V3;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var query = await QueryResource.CreateAsync(
            insightsQueryRequest: new QueryResource.InsightsQueryRequest.Builder()
                .WithDomain("Conversations")
                .WithQuery(
                    new QueryResource.QueryDefinition.Builder()
                        .WithDimensions(new List<string> {
                            "OperatorResult.ConversationId",
                            "OperatorResult.OperatorName",
                            "OperatorResult.KnowledgeBaseId"
                        })
                        .WithFilters(new List<QueryResource.QueryDefinitionFilters> {
                            new QueryResource.QueryDefinitionFilters.Builder()
                                .WithOp("AND")
                                .WithExpressions(new List<
                                                 QueryResource.QueryDefinitionFiltersExpressions> {
                                    new QueryResource.QueryDefinitionFiltersExpressions.Builder()
                                        .WithOp("GT")
                                        .WithField("OperatorResult.CreatedDate")
                                        .WithValues(new List<string> { "2026-04-10" })
                                        .Build(),
                                    new QueryResource.QueryDefinitionFiltersExpressions.Builder()
                                        .WithOp("EQ")
                                        .WithField("OperatorResult.KnowledgeBaseId")
                                        .WithValues(new List<string> {
                                            "know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
                                        })
                                        .Build()
                                })
                                .Build()
                        })
                        .Build())
                .Build());

        Console.WriteLine(query.Domain);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import com.twilio.Twilio;
import com.twilio.rest.insights.v3.Query;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

        Query.QueryDefinitionFiltersExpressions queryDefinitionFiltersExpressions1 =
            Query.QueryDefinitionFiltersExpressions.builder(Query.Op.GT, "OperatorResult.CreatedDate")
                .values(Arrays.asList("2026-04-10"))
                .build();

        Query.QueryDefinitionFiltersExpressions queryDefinitionFiltersExpressions2 =
            Query.QueryDefinitionFiltersExpressions.builder(Query.Op.EQ, "OperatorResult.KnowledgeBaseId")
                .values(Arrays.asList("know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"))
                .build();

        Query.QueryDefinitionFilters queryDefinitionFilters1 =
            Query.QueryDefinitionFilters
                .builder(Arrays.asList(queryDefinitionFiltersExpressions1, queryDefinitionFiltersExpressions2))
                .op(Query.Op.AND)
                .build();

        Query.QueryDefinition queryDefinition =
            Query.QueryDefinition.builder()
                .dimensions(Arrays.asList(
                    "OperatorResult.ConversationId", "OperatorResult.OperatorName", "OperatorResult.KnowledgeBaseId"))
                .filters(Arrays.asList(queryDefinitionFilters1))
                .build();

        Query.InsightsQueryRequest insightsQueryRequest =
            Query.InsightsQueryRequest.builder(queryDefinition).domain("Conversations").build();

        Query.CreateQueryResponse response = Query.creator(insightsQueryRequest).create();

        System.out.println(response.getDomain());
    }
}
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

query = @client
        .insights
        .v3
        .query
        .create(
          insights_query_request: {
            'domain' => 'Conversations',
            'query' => {
              'dimensions' => [
                'OperatorResult.ConversationId',
                'OperatorResult.OperatorName',
                'OperatorResult.KnowledgeBaseId'
              ],
              'filters' => [
                {
                  'op' => 'AND',
                  'expressions' => [
                    {
                      'op' => 'GT',
                      'field' => 'OperatorResult.CreatedDate',
                      'values' => [
                        '2026-04-10'
                      ]
                    },
                    {
                      'op' => 'EQ',
                      'field' => 'OperatorResult.KnowledgeBaseId',
                      'values' => [
                        'know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx'
                      ]
                    }
                  ]
                }
              ]
            }
          }
        )

puts query.domain
```

```bash
INSIGHTS_QUERY_REQUEST_OBJ=$(cat << EOF
{
  "domain": "Conversations",
  "query": {
    "dimensions": [
      "OperatorResult.ConversationId",
      "OperatorResult.OperatorName",
      "OperatorResult.KnowledgeBaseId"
    ],
    "filters": [
      {
        "op": "AND",
        "expressions": [
          {
            "op": "GT",
            "field": "OperatorResult.CreatedDate",
            "values": [
              "2026-04-10"
            ]
          },
          {
            "op": "EQ",
            "field": "OperatorResult.KnowledgeBaseId",
            "values": [
              "know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
            ]
          }
        ]
      }
    ]
  }
}
EOF
)
curl -X POST "https://insights.twilio.com/v3/InsightsDomains/Conversations/Query" \
--json "$INSIGHTS_QUERY_REQUEST_OBJ" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

The response returns operator results filtered by the specified Knowledge Base:

```json
{
  "domain": "Conversations",
  "items": [
    {
      "OperatorResult.ConversationId": "conv_conversation_xxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "OperatorResult.OperatorName": "Sentiment",
      "OperatorResult.KnowledgeBaseId": "know_knowledgebase_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    }
  ],
  "meta": {
    "key": "items",
    "nextToken": null,
    "pageSize": 1,
    "previousToken": null
  }
}
```

## Next steps

To learn more about Conversation Insights, see the following resources:

* [Data model](/docs/conversations/intelligence/conversation-insights/data-model): understand cubes, measures, and dimensions.
* [Query syntax](/docs/conversations/intelligence/conversation-insights/query-syntax): learn how to construct complex queries with filters, ordering, and pagination.