curl --request GET \
  --url 'https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer?datamartName=sales-analytics' \
  --header 'Authorization: Bearer dbn_live_abc123...'

const datamartName = 'sales-analytics';
const response = await fetch(
  `https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer?datamartName=${encodeURIComponent(datamartName)}`,
  {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer dbn_live_abc123...'
    }
  }
);

const result = await response.json();
console.log('Tables:', result.data.tables.length);
console.log('Completion:', result.data.completionScore);

import requests

response = requests.get(
    'https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer',
    headers={
        'Authorization': 'Bearer dbn_live_abc123...'
    },
    params={
        'datamartName': 'sales-analytics'
    }
)

result = response.json()
print(f"Tables: {len(result['data']['tables'])}")
print(f"Completion: {result['data']['completionScore']}%")

require 'net/http'
require 'json'

uri = URI('https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer')
params = { datamartName: 'sales-analytics' }
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer dbn_live_abc123...'

response = http.request(request)
result = JSON.parse(response.body)
puts "Tables: #{result['data']['tables'].length}"

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class GetSemanticLayer {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String datamartName = URLEncoder.encode("sales-analytics", StandardCharsets.UTF_8);
        String url = String.format(
            "https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer?datamartName=%s",
            datamartName
        );

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer dbn_live_abc123...")
            .GET()
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

package main

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

func main() {
    baseURL := "https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer"
    params := url.Values{}
    params.Add("datamartName", "sales-analytics")

    fullURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())

    req, _ := http.NewRequest("GET", fullURL, nil)
    req.Header.Set("Authorization", "Bearer dbn_live_abc123...")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("Response: %v\n", result)
}

<?php
$params = http_build_query([
    'datamartName' => 'sales-analytics'
]);

$url = 'https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer?' . $params;

$options = [
    'http' => [
        'header' => 'Authorization: Bearer dbn_live_abc123...',
        'method' => 'GET'
    ]
];

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

echo "Tables: " . count($response['data']['tables']);
?>

{
  "data": {
    "datamartName": "sales-analytics",
    "tables": [
      {
        "name": "orders",
        "schemaName": "public",
        "description": "Customer purchase orders",
        "synonyms": ["purchases", "transactions"],
        "miscellaneousInfo": null,
        "columns": [
          {
            "name": "order_id",
            "datatype": "integer",
            "description": "Unique order identifier",
            "synonyms": ["id", "order number"],
            "miscellaneousInfo": null,
            "columnType": "Identifier",
            "columnTypeConfig": null,
            "isIdentifier": true,
            "isNotIndexed": false
          },
          {
            "name": "status",
            "datatype": "varchar",
            "description": "Current order status",
            "synonyms": ["order status", "state"],
            "miscellaneousInfo": null,
            "columnType": "ENUM",
            "columnTypeConfig": null,
            "isIdentifier": false,
            "isNotIndexed": false
          },
          {
            "name": "amount",
            "datatype": "numeric",
            "description": "Total order amount in USD",
            "synonyms": ["total", "price"],
            "miscellaneousInfo": null,
            "columnType": "Number",
            "columnTypeConfig": null,
            "isIdentifier": false,
            "isNotIndexed": false
          }
        ]
      }
    ],
    "feedback": "This datamart covers e-commerce sales data. Amounts are in USD.",
    "completionScore": 75,
    "lastUpdated": "2026-03-15T10:30:00.000Z"
  }
}

{
  "data": {
    "datamartName": "raw-datamart",
    "tables": [
      {
        "name": "events",
        "schemaName": "public",
        "description": null,
        "synonyms": [],
        "miscellaneousInfo": null,
        "columns": [
          {
            "name": "event_id",
            "datatype": "integer",
            "description": null,
            "synonyms": [],
            "miscellaneousInfo": null,
            "columnType": null,
            "columnTypeConfig": null,
            "isIdentifier": false,
            "isNotIndexed": false
          }
        ]
      }
    ],
    "feedback": null,
    "completionScore": 0,
    "lastUpdated": null
  }
}

{
  "error": {
    "code": "INVALID_DATAMART",
    "message": "datamartName query parameter is required"
  }
}

{
  "error": {
    "code": "INVALID_DATAMART",
    "message": "Datamart 'nonexistent' not found"
  }
}

{
  "error": {
    "code": "AUTHENTICATION_ERROR",
    "message": "Semantic Layer API requires a service token, not a data app API token"
  }
}