Basic Operations

Manage individual records using ekoDB's REST API. All operations support JSON payloads and return structured responses.

Authentication

All API requests require authentication via JWT tokens. Generate a token from your API key:

curl -X POST https://{EKODB_API_URL}/api/auth/token \
  -H "Content-Type: application/json" \
  -d '{"api_key": "YOUR_API_KEY"}'

Response:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

Use this token in all subsequent requests:

-H "Authorization: Bearer {YOUR_API_TOKEN}"

:::tip Token Expiration Tokens expire after 1 hour by default. Client libraries handle token refresh automatically. :::

Configuration

Update ekoDB instance configuration via the REST API.

PUT https://{EKODB_API_URL}/api/config
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "use_typed_values": true
}

# Response
{
  "status": "success",
  "use_typed_values": true
}

Common Configuration Options:

Option	Type	Default	Description
`use_typed_values`	boolean	`true`	Enable typed field values for records
`storage_mode`	string	`"fast"`	Record persistence strategy (below)
`durable_operations`	boolean	`true`	Enable fsync on every write
`group_commits`	boolean	`true`	Batch concurrent writes for throughput

:::tip Full Configuration Reference See Configuration for the complete list of all available options including LLM providers, chat settings, resource allocation, write performance tuning, and more. :::

Storage Mode

Control how ekoDB persists records to disk. Choose based on your workload characteristics.

PUT https://{EKODB_API_URL}/api/config
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "storage_mode": "cold"
}

Available Modes:

Mode	Write Speed	Read Speed	Disk Usage	Best For
`fast`	Fastest	Fastest	WAL only	Low-latency reads, WAL durability (default)
`balanced`	Fast	Fastest	Periodic batches	General web apps, APIs with disk persistence
`cold`	Fast	Moderate	Minimal	Log ingestion, event streaming, archival

Mode Details:

fast: In-memory + WAL only, no individual record files. Maximum throughput with data recoverable from WAL on restart.
balanced: Fast critical path (same as fast mode) + periodic checkpoint batching to disk. Near-fast-mode performance with eventual disk persistence.
cold: Append-only storage optimized for high-volume write ingestion with significant disk space savings.

:::tip Choosing a Storage Mode

Use fast (default) for most workloads - provides low-latency reads with WAL-based durability
Use balanced when you need periodic disk checkpoints for additional persistence
Use cold for write-heavy workloads like logging, events, or time-series data

:::

Insert Record

Create a new record in a collection.

Client Libraries (Recommended)
Direct API

use ekodb_client::Client;

let mut record = Record::new();
record.insert("name", "John Doe");
record.insert("email", "john@example.com");
record.insert("age", 30);

let result = client.insert("users", record).await?;

println!("Record ID: {}", result.id);

from ekodb_client import Client

client = Client.new(
    os.getenv('EKODB_URL'),
    os.getenv('EKODB_API_KEY')
)

result = await client.insert('users', {
    'name': 'John Doe',
    'email': 'john@example.com',
    'age': 30
})

print(result['id'])  # record_id_123

import { EkoDBClient } from '@ekodb/ekodb-client';

const client = new EkoDBClient({
  baseURL: process.env.EKODB_URL,
  apiKey: process.env.EKODB_API_KEY,
});
await client.init();

const result = await client.insert('users', {
  name: 'John Doe',
  email: 'john@example.com',
  age: 30
});

console.log(result.id); // record_id_123

const { EkoDBClient } = require('@ekodb/ekodb-client');

const client = new EkoDBClient({
  baseURL: process.env.EKODB_URL,
  apiKey: process.env.EKODB_API_KEY,
});
await client.init();

const result = await client.insert('users', {
  name: 'John Doe',
  email: 'john@example.com',
  age: 30
});

console.log(result.id); // record_id_123

import io.ekodb.client.EkoDBClient

val client = EkoDBClient.builder()
    .baseUrl(System.getenv("EKODB_URL"))
    .apiKey(System.getenv("EKODB_API_KEY"))
    .build()

val result = client.insert("users", mapOf(
    "name" to "John Doe",
    "email" to "john@example.com",
    "age" to 30
))

println("Record ID: ${result.id}")

import "github.com/ekoDB/ekodb-client-go"

client := ekodb.NewClient(
    os.Getenv("EKODB_URL"),
    os.Getenv("EKODB_API_KEY"),
)

result, err := client.Insert("users", map[string]interface{}{
    "name":  "John Doe",
    "email": "john@example.com",
    "age":   30,
})

fmt.Println("Record ID:", result.ID)

curl -X POST https://{EKODB_API_URL}/api/insert/users \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "John Doe",
    "email": "john@example.com",
    "age": 30
  }'

# Response
{
  "id": "record_id_123"
}

:::tip Get Full Record After Insert The insert operation returns only the record ID. To retrieve the full record with all fields, use a GET request with the returned ID. :::

Disable Real-Time Data Propagation (Ripples):

By default, all write operations (insert, update, delete) automatically propagate to configured peer nodes via the Ripple system. Use bypass_ripple=true to skip propagation for specific operations:

When to bypass:

Background jobs that process locally
Temporary data that doesn't need replication
Development/testing operations
Operations during maintenance windows

POST https://{EKODB_API_URL}/api/insert/{collection}?bypass_ripple=true
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "name": "Local Processing User",
  "email": "local@example.com"
}

Get Record by ID

Retrieve a specific record by its ID.

Client Libraries (Recommended)
Direct API

let record = client.find_by_id("users", "record_id_123").await?;

println!("{:?}", record);

record = await client.find_by_id('users', 'record_id_123')

print(record)
# {
#   'id': 'record_id_123',
#   'name': 'John Doe',
#   'email': 'john@example.com',
#   'age': 30,
#   'created_at': '2026-01-15T10:30:00Z'
# }

const record = await client.findById('users', 'record_id_123');

console.log(record);
// {
//   id: 'record_id_123',
//   name: 'John Doe',
//   email: 'john@example.com',
//   age: 30,
//   created_at: '2026-01-15T10:30:00Z'
// }

const record = await client.findById('users', 'record_id_123');

console.log(record);
// {
//   id: 'record_id_123',
//   name: 'John Doe',
//   email: 'john@example.com',
//   age: 30,
//   created_at: '2026-01-15T10:30:00Z'
// }

val record = client.findById("users", "record_id_123")

println(record)

record, err := client.FindByID("users", "record_id_123")

fmt.Println(record)

curl https://{EKODB_API_URL}/api/find/users/record_id_123 \
  -H "Authorization: Bearer {TOKEN}"

# Response
{
  "id": "record_id_123",
  "name": "John Doe",
  "email": "john@example.com",
  "age": 30,
  "created_at": "2026-01-15T10:30:00Z"
}

Query Records

Query records with filters, sorting, and pagination.

Client Libraries (Recommended)
Direct API

use ekodb_client::QueryBuilder;

let query = QueryBuilder::new()
    .gt("age", 25)
    .sort_desc("created_at")
    .limit(10)
    .skip(0)
    .build();
let results = client.find("users", query, None).await?;

println!("{:?}", results);

from ekodb_client import QueryBuilder

query = QueryBuilder().gt("age", 25).sort_desc("created_at").limit(10).build()
results = await client.find("users", query)

print(results)

import { QueryBuilder } from '@ekodb/ekodb-client';

const query = new QueryBuilder()
  .gt("age", 25)
  .sortDesc("created_at")
  .limit(10)
  .build();

const results = await client.find("users", query);

console.log(results);

const { QueryBuilder } = require('@ekodb/ekodb-client');

const query = new QueryBuilder()
  .gt("age", 25)
  .sortDesc("created_at")
  .limit(10)
  .build();

const results = await client.find("users", query);

console.log(results);

val query = QueryBuilder()
    .gt("age", 25)
    .sortDesc("created_at")
    .limit(10)
    .build()

val results = client.find("users", query)

println(results)

query := ekodb.NewQueryBuilder().
    Gt("age", 25).
    SortDescending("created_at").
    Limit(10).
    Build()

results, err := client.Find("users", query)

fmt.Println(results)

curl -X POST https://{EKODB_API_URL}/api/find/users \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "Condition",
      "content": {
        "field": "age",
        "operator": "Gt",
        "value": 25
      }
    },
    "sort": {
      "field": "created_at",
      "order": "desc"
    },
    "limit": 10,
    "offset": 0
  }'

# Response
{
  "records": [
    {
      "id": "record_1",
      "name": "John Doe",
      "age": 30
    },
    {
      "id": "record_2",
      "name": "Jane Smith",
      "age": 28
    }
  ],
  "total": 2
}

See Query Expressions for detailed filter syntax.

Query Operators:

Short Form	Long Form	Description
`Eq`	`Equals`	Exact match
`Ne`	`NotEquals`	Not equal to
`Gt`	`GreaterThan`	Greater than
`Lt`	`LessThan`	Less than
`Gte`	`GreaterThanOrEqual`	Greater than or equal
`Lte`	`LessThanOrEqual`	Less than or equal
`Contains`	-	String contains (case-sensitive)
`StartsWith`	-	String starts with
`EndsWith`	-	String ends with

:::info Logical Operators For combining filters with AND, OR, and NOT operations, see the Query Expressions reference for the correct JSON structure. :::

Combine Filters with AND:

{
  "filter": {
    "type": "Logical",
    "content": {
      "operator": "And",
      "expressions": [
        {
          "type": "Condition",
          "content": {
            "field": "age",
            "operator": "Gt",
            "value": 25
          }
        },
        {
          "type": "Condition",
          "content": {
            "field": "status",
            "operator": "Eq",
            "value": "active"
          }
        }
      ]
    }
  }
}

Combine Filters with OR:

{
  "filter": {
    "type": "Logical",
    "content": {
      "operator": "Or",
      "expressions": [
        {
          "type": "Condition",
          "content": {
            "field": "role",
            "operator": "Eq",
            "value": "admin"
          }
        },
        {
          "type": "Condition",
          "content": {
            "field": "role",
            "operator": "Eq",
            "value": "moderator"
          }
        }
      ]
    }
  }
}

Complex Nested Filters:

Find active users who are either admins OR (have age > 25 AND verified):

{
  "filter": {
    "type": "Logical",
    "content": {
      "operator": "And",
      "expressions": [
        {
          "type": "Condition",
          "content": {
            "field": "status",
            "operator": "Eq",
            "value": "active"
          }
        },
        {
          "type": "Logical",
          "content": {
            "operator": "Or",
            "expressions": [
              {
                "type": "Condition",
                "content": {
                  "field": "role",
                  "operator": "Eq",
                  "value": "admin"
                }
              },
              {
                "type": "Logical",
                "content": {
                  "operator": "And",
                  "expressions": [
                    {
                      "type": "Condition",
                      "content": {
                        "field": "age",
                        "operator": "Gt",
                        "value": 25
                      }
                    },
                    {
                      "type": "Condition",
                      "content": {
                        "field": "verified",
                        "operator": "Eq",
                        "value": true
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}

:::tip Advanced Queries For complex queries with nested filters and advanced operations, see the Query Expressions reference. Using a client library? See Client Libraries - Querying with Filters. :::

Update Record

Update an existing record by ID.

Client Libraries (Recommended)
Direct API

let mut updates = Record::new();
updates.insert("email", "newemail@example.com");
updates.insert("age", 31);

let result = client.update("users", "record_id_123", updates).await?;

println!("Record ID: {}", result.id);

result = await client.update('users', 'record_id_123', {
    'email': 'newemail@example.com',
    'age': 31
})

print(result['id'])  # record_id_123

const result = await client.update('users', 'record_id_123', {
  email: 'newemail@example.com',
  age: 31
});

console.log(result.id); // record_id_123

const result = await client.update('users', 'record_id_123', {
  email: 'newemail@example.com',
  age: 31
});

console.log(result.id); // record_id_123

val result = client.update("users", "record_id_123", mapOf(
    "email" to "newemail@example.com",
    "age" to 31
))

println("Record ID: ${result.id}")

result, err := client.Update("users", "record_id_123", map[string]interface{}{
    "email": "newemail@example.com",
    "age":   31,
})

fmt.Println("Record ID:", result.ID)

curl -X PUT https://{EKODB_API_URL}/api/update/users/record_id_123 \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "newemail@example.com",
    "age": 31
  }'

# Response
{
  "id": "record_id_123",
  "message": "Record updated successfully"
}

:::tip Partial Updates Only the fields provided in the request body are updated. Existing fields remain unchanged. :::

Search Records

Full-text and semantic search across records.

POST https://{EKODB_API_URL}/api/search/{collection}
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "query": "software engineer",
  "limit": 10,
  "offset": 0
}

# Response
{
  "results": [
    {
      "record": {
        "id": "record_1",
        "name": "John Doe",
        "title": "Senior Software Engineer"
      },
      "score": 0.95
    }
  ],
  "total": 1
}

Search with Vector Similarity:

POST https://{EKODB_API_URL}/api/search/{collection}
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "query": "machine learning",
  "vector_field": "embedding",
  "limit": 5,
  "similarity_threshold": 0.8
}

GET Alternative:

GET https://{EKODB_API_URL}/api/search/{collection}?query=software%20engineer&limit=10
Authorization: Bearer {YOUR_API_TOKEN}

Delete Record

Delete a record by ID (moves to trash for 30 days before permanent deletion).

Client Libraries (Recommended)
Direct API

let deleted_record = client.delete("users", "record_id_123").await?;

println!("{:?}", deleted_record);
// Returns the full deleted record

deleted_record = await client.delete('users', 'record_id_123')

print(deleted_record)
# Returns the full deleted record

const deletedRecord = await client.delete('users', 'record_id_123');

console.log(deletedRecord);
// Returns the full deleted record

const deletedRecord = await client.delete('users', 'record_id_123');

console.log(deletedRecord);
// Returns the full deleted record

val deletedRecord = client.delete("users", "record_id_123")

println(deletedRecord)
// Returns the full deleted record

deletedRecord, err := client.Delete("users", "record_id_123")

fmt.Println(deletedRecord)
// Returns the full deleted record

curl -X DELETE https://{EKODB_API_URL}/api/delete/users/record_id_123 \
  -H "Authorization: Bearer {TOKEN}"

# Response
{
  "id": "record_id_123",
  "name": "John Doe",
  "email": "john@example.com",
  "age": 30
}

:::tip Deleted Record Returned The delete operation returns the full deleted record, useful for undo operations or audit logs. :::

Disable Real-Time Sync:

DELETE https://{EKODB_API_URL}/api/delete/{collection}/{record_id}?bypass_ripple=true
Authorization: Bearer {YOUR_API_TOKEN}

Collection-Level Operations

:::info Full Collection Management For complete schema definitions, field types, and advanced collection configuration, see Collections & Schemas. :::

Create Collection

Create a new collection with an optional schema.

POST https://{EKODB_API_URL}/api/collections/{collection}
Content-Type: application/json
Authorization: Bearer {ADMIN_TOKEN}

{
  "fields": {
    "name": {
      "type": "string",
      "required": true
    },
    "email": {
      "type": "string",
      "required": true
    },
    "age": {
      "type": "number"
    }
  }
}

# Response
{
  "status": "success",
  "message": "Collection initialized successfully"
}

:::info Working Examples Want to use the REST API directly? See examples in JavaScript, Python, Go, or Rust

Prefer a client library? See examples in Rust, Python, TypeScript, Go, or Kotlin :::

List Collections

Get a list of all collections in the database.

GET https://{EKODB_API_URL}/api/collections
Authorization: Bearer {YOUR_API_TOKEN}

# Response
{
  "collections": [
    {
      "name": "users",
      "record_count": 1234,
      "created_at": "2026-01-10T08:00:00Z"
    },
    {
      "name": "products",
      "record_count": 567,
      "created_at": "2026-01-12T10:30:00Z"
    }
  ]
}

Get Collection Info

Retrieve information about a specific collection.

GET https://{EKODB_API_URL}/api/collections/{collection}
Authorization: Bearer {YOUR_API_TOKEN}

# Response
{
  "name": "users",
  "record_count": 1234,
  "schema": { ... },
  "created_at": "2026-01-10T08:00:00Z"
}

Update Schema

Update validation constraints for an existing collection schema.

PUT https://{EKODB_API_URL}/api/schemas/{collection}
Content-Type: application/json
Authorization: Bearer {ADMIN_TOKEN}

{
  "constraints": {
    "email": {
      "required": true,
      "unique": true
    }
  }
}

# Response
{
  "status": "success",
  "message": "Schema constraints updated successfully"
}

:::warning Schema Updates Schema updates only affect new records. Existing records are not automatically migrated or validated against the new schema. :::

Delete Collection

DELETE https://{EKODB_API_URL}/api/collections/{collection}
Authorization: Bearer {ADMIN_TOKEN}

Restore from Trash

# Restore single record
POST https://{EKODB_API_URL}/api/trash/{collection}/{record_id}
Authorization: Bearer {ADMIN_TOKEN}

# Restore all records in collection
POST https://{EKODB_API_URL}/api/trash/{collection}
Authorization: Bearer {ADMIN_TOKEN}

:::tip Full Details For complete Delete and Restore documentation including response formats and trash retention policies, see Collections & Schemas - Delete Collection. :::

Using Operations Within Transactions

All write operations (insert, update, delete) can be performed within a transaction by adding the transaction_id query parameter. Operations are tracked and can be committed or rolled back together.

Insert Within Transaction:

POST https://{EKODB_API_URL}/api/insert/users?transaction_id=tx-001
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "name": "John Doe",
  "email": "john@example.com"
}

Update Within Transaction:

PUT https://{EKODB_API_URL}/api/update/users/user_123?transaction_id=tx-001
Content-Type: application/json
Authorization: Bearer {YOUR_API_TOKEN}

{
  "status": "active"
}

Delete Within Transaction:

DELETE https://{EKODB_API_URL}/api/delete/users/user_123?transaction_id=tx-001
Authorization: Bearer {YOUR_API_TOKEN}

Complete Transaction Example:

# 1. Begin transaction
tx_id=$(curl -s -X POST https://{EKODB_API_URL}/api/transactions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{"isolation_level": "Serializable"}' | jq -r '.transaction_id')

# 2. Insert record in transaction
curl -X POST https://{EKODB_API_URL}/api/insert/users?transaction_id=$tx_id \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{"name": "Jane Doe", "email": "jane@example.com"}'

# 3. Update record in transaction
curl -X PUT https://{EKODB_API_URL}/api/update/users/user_456?transaction_id=$tx_id \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{"status": "verified"}'

# 4. Commit transaction (or rollback if needed)
curl -X POST https://{EKODB_API_URL}/api/transactions/$tx_id/commit \
  -H "Authorization: Bearer {YOUR_API_TOKEN}"

:::tip Transaction Support For full transaction management including savepoints and rollback capabilities, see the Transactions documentation. :::

Complete Example

Here's a complete workflow for creating and managing a user:

# 1. Insert user
curl -X POST https://{EKODB_API_URL}/api/insert/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{
    "name": "John Doe",
    "email": "john@example.com",
    "age": 30,
    "status": "pending"
  }'
# Response: {"id": "user_123", ...}

# 2. Get user by ID
curl -X GET https://{EKODB_API_URL}/api/find/users/user_123 \
  -H "Authorization: Bearer {YOUR_API_TOKEN}"

# 3. Update user status
curl -X PUT https://{EKODB_API_URL}/api/update/users/user_123 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{
    "status": "active",
    "activated_at": "2026-01-15T11:00:00Z"
  }'

# 4. Query active users
curl -X POST https://{EKODB_API_URL}/api/find/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{
    "filter": {
      "type": "Condition",
      "content": {
        "field": "status",
        "operator": "Eq",
        "value": "active"
      }
    },
    "limit": 10
  }'

# 5. Search users
curl -X POST https://{EKODB_API_URL}/api/search/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {YOUR_API_TOKEN}" \
  -d '{
    "query": "john",
    "limit": 5
  }'

# 6. Delete user
curl -X DELETE https://{EKODB_API_URL}/api/delete/users/user_123 \
  -H "Authorization: Bearer {YOUR_API_TOKEN}"

Best Practices

Use Appropriate HTTP Methods

# Create - POST
POST /api/insert/{collection}

# Read - GET
GET /api/find/{collection}/{id}

# Update - PUT
PUT /api/update/{collection}/{id}

# Delete - DELETE
DELETE /api/delete/{collection}/{id}

Handle Errors Gracefully

# Check status code
response=$(curl -s -w "\n%{http_code}" -X GET .../api/find/users/user_123)
status_code=$(echo "$response" | tail -n1)
body=$(echo "$response" | sed '$d')

if [ "$status_code" != "200" ]; then
  echo "Error: $body"
fi

Use Filters for Efficient Queries

# Good: Filter on indexed fields
POST /api/find/users
{"filter": {"field": "status", "operator": "Eq", "value": "active"}}

# Good: Limit results
POST /api/find/users
{"filter": {...}, "limit": 100}

# Avoid: Fetching all records without filter
POST /api/find/users
{"limit": 10000}  # Use pagination instead

Pagination for Large Result Sets

# Page 1
POST /api/find/users
{"limit": 100, "offset": 0}

# Page 2
POST /api/find/users
{"limit": 100, "offset": 100}

# Page 3
POST /api/find/users
{"limit": 100, "offset": 200}

Query Examples

Simple Equality Query

curl -X POST https://your-db.ekodb.net/api/find/users \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "Condition",
      "content": {
        "field": "status",
        "operator": "Eq",
        "value": "active"
      }
    }
  }'

Range Query (Age Between 18 and 65)

curl -X POST https://your-db.ekodb.net/api/find/users \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "Logical",
      "content": {
        "operator": "And",
        "expressions": [
          {
            "type": "Condition",
            "content": {
              "field": "age",
              "operator": "Gte",
              "value": 18
            }
          },
          {
            "type": "Condition",
            "content": {
              "field": "age",
              "operator": "Lte",
              "value": 65
            }
          }
        ]
      }
    },
    "sort": [
      {
        "field": "age",
        "ascending": true
      }
    ],
    "limit": 50
  }'

String Contains Query

curl -X POST https://your-db.ekodb.net/api/find/users \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "Condition",
      "content": {
        "field": "email",
        "operator": "Contains",
        "value": "@gmail.com"
      }
    }
  }'

IN Array Query

curl -X POST https://your-db.ekodb.net/api/find/users \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "Condition",
      "content": {
        "field": "role",
        "operator": "In",
        "value": ["admin", "moderator", "editor"]
      }
    }
  }'

:::tip Query Expression Reference For a complete reference of all operators and query patterns, see Query Expressions. :::

Query Expressions - Complete query operators reference
Batch Operations - Bulk operations for multiple records
Transactions - ACID transactions for atomicity
Collections & Schemas - Create and manage collections
KV Store - Simple key-value operations
Client Libraries - Language-specific client libraries
Authentication - API key and JWT authentication

Example Code

Direct HTTP/REST API Examples

Raw HTTP examples demonstrating the REST API directly:

JavaScript - simple_crud.js
Python - simple_crud.py
Go - simple_crud.go
Rust - simple_crud.rs

Client Library Examples

Production-ready examples using official client libraries:

Rust - client_simple_crud.rs
Python - client_simple_crud.py
TypeScript - client_simple_crud.ts
Go - client_simple_crud.go
Kotlin - ClientSimpleCrud.kt
JavaScript - client_simple_crud.js

Authentication​

Configuration​

Storage Mode​

Insert Record​

Get Record by ID​

Query Records​

Update Record​

Search Records​

Delete Record​

Collection-Level Operations​

Create Collection​

List Collections​

Get Collection Info​

Update Schema​

Delete Collection​

Restore from Trash​

Using Operations Within Transactions​

Complete Example​

Best Practices​

Use Appropriate HTTP Methods​

Handle Errors Gracefully​

Use Filters for Efficient Queries​

Pagination for Large Result Sets​

Query Examples​

Simple Equality Query​

Range Query (Age Between 18 and 65)​

String Contains Query​

IN Array Query​

Related Documentation​

Example Code​

Direct HTTP/REST API Examples​

Client Library Examples​