curl --request POST \
  --url https://api.usedatabrain.com/api/v2/data-app/query \
  --header 'Authorization: Bearer dbn_live_abc123...' \
  --header 'Content-Type: application/json' \
  --data '{
    "embedId": "embed_123",
    "metricId": "metric_456",
    "clientId": "user_789",
    "dashboardFilter": {
      "date_range": {
        "start": "2024-01-01",
        "end": "2024-01-31"
      }
    },
    "metricFilter": {
      "region": "north-america"
    }
  }'

const response = await fetch('https://api.usedatabrain.com/api/v2/data-app/query', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer dbn_live_abc123...',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    embedId: 'embed_123',
    metricId: 'metric_456',
    clientId: 'user_789',
    dashboardFilter: {
      date_range: {
        start: '2024-01-01',
        end: '2024-01-31'
      }
    },
    metricFilter: {
      region: 'north-america'
    }
  })
});

const data = await response.json();
console.log('Query results:', data.data.length, 'rows');
console.log('Time taken:', data.timeTaken, 'ms');

import requests
import json

url = "https://api.usedatabrain.com/api/v2/data-app/query"
headers = {
    "Authorization": "Bearer dbn_live_abc123...",
    "Content-Type": "application/json"
}
payload = {
    "embedId": "embed_123",
    "metricId": "metric_456",
    "clientId": "user_789",
    "dashboardFilter": {
        "date_range": {
            "start": "2024-01-01",
            "end": "2024-01-31"
        }
    },
    "metricFilter": {
        "region": "north-america"
    }
}

response = requests.post(url, headers=headers, data=json.dumps(payload))
data = response.json()
print(f"Query results: {len(data['data'])} rows")
print(f"Time taken: {data['timeTaken']} ms")

require 'net/http'
require 'json'

uri = URI('https://api.usedatabrain.com/api/v2/data-app/query')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer dbn_live_abc123...'
request['Content-Type'] = 'application/json'
request.body = {
  embedId: 'embed_123',
  metricId: 'metric_456',
  clientId: 'user_789',
  dashboardFilter: {
    date_range: {
      start: '2024-01-01',
      end: '2024-01-31'
    }
  },
  metricFilter: {
    region: 'north-america'
  }
}.to_json

response = http.request(request)
data = JSON.parse(response.body)
puts "Query results: #{data['data'].length} rows"
puts "Time taken: #{data['timeTaken']} ms"

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.HashMap;

public class DataBrainQueryAPI {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        ObjectMapper mapper = new ObjectMapper();
        
        Map<String, Object> dashboardFilter = new HashMap<>();
        Map<String, String> dateRange = new HashMap<>();
        dateRange.put("start", "2024-01-01");
        dateRange.put("end", "2024-01-31");
        dashboardFilter.put("date_range", dateRange);
        
        Map<String, Object> metricFilter = new HashMap<>();
        metricFilter.put("region", "north-america");
        
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("embedId", "embed_123");
        requestBody.put("metricId", "metric_456");
        requestBody.put("clientId", "user_789");
        requestBody.put("dashboardFilter", dashboardFilter);
        requestBody.put("metricFilter", metricFilter);
        
        String jsonBody = mapper.writeValueAsString(requestBody);
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.usedatabrain.com/api/v2/data-app/query"))
            .header("Authorization", "Bearer dbn_live_abc123...")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
            
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
            
        System.out.println("Response: " + response.body());
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type QueryRequest struct {
    EmbedId         string                 `json:"embedId"`
    MetricId        string                 `json:"metricId"`
    ClientId        string                 `json:"clientId"`
    DashboardFilter map[string]interface{} `json:"dashboardFilter,omitempty"`
    MetricFilter    map[string]interface{} `json:"metricFilter,omitempty"`
}

type QueryResponse struct {
    Data         []map[string]interface{} `json:"data"`
    TimeTaken    int                      `json:"timeTaken"`
    TotalRecords int                      `json:"totalRecords"`
    MetaData     map[string]interface{}   `json:"metaData"`
}

func main() {
    reqBody := QueryRequest{
        EmbedId:  "embed_123",
        MetricId: "metric_456",
        ClientId: "user_789",
        DashboardFilter: map[string]interface{}{
            "date_range": map[string]string{
                "start": "2024-01-01",
                "end":   "2024-01-31",
            },
        },
        MetricFilter: map[string]interface{}{
            "region": "north-america",
        },
    }
    
    jsonData, _ := json.Marshal(reqBody)
    
    req, _ := http.NewRequest("POST", 
        "https://api.usedatabrain.com/api/v2/data-app/query", 
        bytes.NewBuffer(jsonData))
    
    req.Header.Set("Authorization", "Bearer dbn_live_abc123...")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var queryResp QueryResponse
    json.NewDecoder(resp.Body).Decode(&queryResp)
    
    fmt.Printf("Query results: %d rows\n", len(queryResp.Data))
    fmt.Printf("Time taken: %d ms\n", queryResp.TimeTaken)
}

<?php
$url = 'https://api.usedatabrain.com/api/v2/data-app/query';
$data = [
    'embedId' => 'embed_123',
    'metricId' => 'metric_456',
    'clientId' => 'user_789',
    'dashboardFilter' => [
        'date_range' => [
            'start' => '2024-01-01',
            'end' => '2024-01-31'
        ]
    ],
    'metricFilter' => [
        'region' => 'north-america'
    ]
];

$options = [
    'http' => [
        'header' => [
            'Authorization: Bearer dbn_live_abc123...',
            'Content-Type: application/json'
        ],
        'method' => 'POST',
        'content' => json_encode($data)
    ]
];

$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
$response = json_decode($result, true);

echo "Query results: " . count($response['data']) . " rows\n";
echo "Time taken: " . $response['timeTaken'] . " ms\n";
?>

{
  "data": [
    {
      "date": "2024-01-01",
      "revenue": 15000,
      "region": "north-america",
      "customer_count": 45
    },
    {
      "date": "2024-01-02", 
      "revenue": 18500,
      "region": "north-america",
      "customer_count": 52
    },
    {
      "date": "2024-01-03",
      "revenue": 16500,
      "region": "north-america",
      "customer_count": 138
    }
  ],
  "timeTaken": 245,
  "comparisonValue": 12500,
  "totalRecords": 31,
  "metaData": {
    "columns": [
      {
        "name": "date",
        "dataType": "date"
      },
      {
        "name": "revenue",
        "dataType": "number"
      },
      {
        "name": "region",
        "dataType": "string"
      },
      {
        "name": "customer_count",
        "dataType": "number"
      }
    ],
    "groupbyColumnList": ["date", "region"]
  },
  "metricid": "metric_456",
  "error": null
}

{
  "data": [],
  "timeTaken": 45,
  "totalRecords": 0,
  "metaData": {
    "columns": [],
    "groupbyColumnList": []
  },
  "metricid": "metric_456",
  "error": null
}

{
  "error": {
    "code": "INVALID_DATA_APP_API_KEY",
    "message": "Invalid or missing Data App API Key"
  }
}

{
  "error": {
    "code": "INVALID_EMBED_ID",
    "message": "Embed ID not found or access denied",
    "status": 400
  }
}

{
  "error": {
    "code": "EMBED_PARAM_ERROR",
    "message": "Embed ID not found or mismatched with API Key"
  }
}