curl --request POST \
  --url https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer \
  --header 'Authorization: Bearer dbn_live_abc123...' \
  --header 'Content-Type: application/json' \
  --data '{
    "datamartName": "sales-analytics",
    "tables": [
      {
        "name": "orders",
        "description": "Customer purchase orders",
        "synonyms": ["purchases", "transactions"],
        "columns": [
          {
            "name": "order_id",
            "description": "Unique order identifier",
            "columnType": "Identifier",
            "isIdentifier": true
          },
          {
            "name": "status",
            "description": "Current order status",
            "synonyms": ["order status", "state"],
            "columnType": "ENUM"
          },
          {
            "name": "amount",
            "description": "Total order amount in USD",
            "columnType": "Number"
          }
        ]
      }
    ],
    "feedback": "This datamart covers e-commerce sales data. All amounts are in USD."
  }'

curl --request POST \
  --url https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer \
  --header 'Authorization: Bearer dbn_live_abc123...' \
  --header 'Content-Type: application/json' \
  --data '{
    "datamartName": "sales-analytics",
    "feedback": "This datamart covers e-commerce sales data. Fiscal year starts April 1."
  }'

const response = await fetch('https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer dbn_live_abc123...',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    datamartName: 'sales-analytics',
    tables: [
      {
        name: 'orders',
        description: 'Customer purchase orders',
        synonyms: ['purchases', 'transactions'],
        columns: [
          {
            name: 'order_id',
            description: 'Unique order identifier',
            columnType: 'Identifier',
            isIdentifier: true
          },
          {
            name: 'amount',
            description: 'Total order amount in USD',
            columnType: 'Number'
          }
        ]
      }
    ],
    feedback: 'All amounts are in USD.'
  })
});

const result = await response.json();

if (result.error) {
  console.error('Create failed:', result.error.message);
} else {
  console.log('Semantic layer created for:', result.id);
}

import requests

response = requests.post(
    'https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer',
    headers={
        'Authorization': 'Bearer dbn_live_abc123...',
        'Content-Type': 'application/json'
    },
    json={
        'datamartName': 'sales-analytics',
        'tables': [
            {
                'name': 'orders',
                'description': 'Customer purchase orders',
                'synonyms': ['purchases', 'transactions'],
                'columns': [
                    {
                        'name': 'order_id',
                        'description': 'Unique order identifier',
                        'columnType': 'Identifier',
                        'isIdentifier': True
                    },
                    {
                        'name': 'amount',
                        'description': 'Total order amount in USD',
                        'columnType': 'Number'
                    }
                ]
            }
        ],
        'feedback': 'All amounts are in USD.'
    }
)

result = response.json()

if result.get('error'):
    print(f"Create failed: {result['error']['message']}")
else:
    print(f"Semantic layer created for: {result['id']}")

require 'net/http'
require 'json'

uri = URI('https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer')
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 = {
  datamartName: 'sales-analytics',
  tables: [
    {
      name: 'orders',
      description: 'Customer purchase orders',
      columns: [
        { name: 'order_id', description: 'Unique order identifier', columnType: 'Identifier' },
        { name: 'amount', description: 'Total order amount', columnType: 'Number' }
      ]
    }
  ],
  feedback: 'All amounts are in USD.'
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts "Created: #{result['id']}"

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

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

        String requestBody = """
            {
                "datamartName": "sales-analytics",
                "tables": [
                    {
                        "name": "orders",
                        "description": "Customer purchase orders",
                        "columns": [
                            {
                                "name": "order_id",
                                "description": "Unique order identifier",
                                "columnType": "Identifier",
                                "isIdentifier": true
                            },
                            {
                                "name": "amount",
                                "description": "Total order amount in USD",
                                "columnType": "Number"
                            }
                        ]
                    }
                ],
                "feedback": "All amounts are in USD."
            }""";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer"))
            .header("Authorization", "Bearer dbn_live_abc123...")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();

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

package main

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

func main() {
    body := map[string]interface{}{
        "datamartName": "sales-analytics",
        "tables": []map[string]interface{}{
            {
                "name":        "orders",
                "description": "Customer purchase orders",
                "columns": []map[string]interface{}{
                    {
                        "name":         "order_id",
                        "description":  "Unique order identifier",
                        "columnType":   "Identifier",
                        "isIdentifier": true,
                    },
                    {
                        "name":        "amount",
                        "description": "Total order amount in USD",
                        "columnType":  "Number",
                    },
                },
            },
        },
        "feedback": "All amounts are in USD.",
    }

    jsonData, _ := json.Marshal(body)

    req, _ := http.NewRequest("POST",
        "https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer",
        bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer dbn_live_abc123...")
    req.Header.Set("Content-Type", "application/json")

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

    fmt.Println("Semantic layer created")
}

<?php
$url = 'https://api.usedatabrain.com/api/v2/data-app/datamarts/semantic-layer';
$data = [
    'datamartName' => 'sales-analytics',
    'tables' => [
        [
            'name' => 'orders',
            'description' => 'Customer purchase orders',
            'columns' => [
                [
                    'name' => 'order_id',
                    'description' => 'Unique order identifier',
                    'columnType' => 'Identifier',
                    'isIdentifier' => true
                ],
                [
                    'name' => 'amount',
                    'description' => 'Total order amount in USD',
                    'columnType' => 'Number'
                ]
            ]
        ]
    ],
    'feedback' => 'All amounts are in USD.'
];

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

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

echo "Created: " . $result['id'];
?>

{
  "id": "sales-analytics"
}

{
  "error": {
    "code": "INVALID_REQUEST_BODY",
    "message": "\"datamartName\" is required"
  }
}

{
  "error": {
    "code": "INVALID_REQUEST_BODY",
    "message": "\"value\" must contain at least one of [tables, feedback]"
  }
}

{
  "error": {
    "code": "INVALID_TABLE",
    "message": "Table 'nonexistent_table' not found in datamart 'sales-analytics'"
  }
}

{
  "error": {
    "code": "INVALID_COLUMN",
    "message": "Column 'nonexistent_col' not found in table 'orders'"
  }
}

{
  "error": {
    "code": "INVALID_COLUMN_TYPE",
    "message": "Column type 'Number' is not compatible with datatype 'varchar' for column 'status' in table 'orders'"
  }
}

{
  "error": {
    "code": "DUPLICATE_SYNONYM",
    "message": "Duplicate synonyms for table 'orders': purchases"
  }
}

{
  "error": {
    "code": "SEMANTIC_LAYER_ALREADY_EXISTS",
    "message": "Semantic layer already exists for datamart 'sales-analytics'. Use PUT to update."
  }
}

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