Skip to main content

AutessaDB API

AutessaDB is a complete database solution with built-in semantic search capabilities. Perform CRUD operations, complex queries, batch updates, join tables, and leverage powerful vector search across your data.

All AutessaDB API requests require the resourceId query parameter set to your table's ID (e.g. V1StGXR8Z5) and an Authorization header with your API key. Your API key must have the appropriate permissions (READ, WRITE, DELETE) for the requested operation.

Base URL​

https://api.autessa.com/clients/autessadb

Authentication​

Pass your API key in the Authorization header (no "Bearer" prefix):

Authorization: your_api_key_here
cURL
curl https://api.autessa.com/clients/autessadb/get-data?resourceId=V1StGXR8Z5 \
  -H "Authorization: your_api_key" \
  -H "Content-Type: application/json"

Permissions​

Each API key can have different permissions for each table:

  • Name
    READ
    Description

    Required for: get-data, query, join-query, aggregate, get-single-row, search

  • Name
    WRITE
    Description

    Required for: insert, update, batch-update, bulk-insert, bulk-update-by-ids, generate-upload-link, index-record

  • Name
    DELETE
    Description

    Required for: delete-row, batch-delete, bulk-delete-by-ids

/create-knowledge-base creates a new table, so no table-level permission applies — the API key authenticates at the company level instead.

Configure permissions for your API key in the Autessa Builder.

Knowledge Bases​

Create Knowledge Base POST/create-knowledge-base​

Creates a knowledge base table pre-configured for semantic search and inserts one row per file. The new table has three columns: full_path (SHORT_TEXT), file_name (SHORT_TEXT, computed automatically from full_path), and file (FILE, vectorized for semantic search).

Permission Required: None at the table level — the endpoint creates a new table, so the API key authenticates at the company level.

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    ID of an AutessaDB table the API key has access to. Required by the gateway even though a new table is created.

Request Body​

  • Name
    tableName
    Type
    string
    Description

    Name for the new knowledge base table.

  • Name
    files
    Type
    array<KnowledgeBaseFile>
    Description

    Files to insert into the knowledge base, at least one. Each file has fullPath (string, the file's full path including folders) and s3Uri (string, the S3 URI of the uploaded file). Files are copied into the knowledge base's permanent storage.

Response​

  • Name
    tableId
    Type
    string
    Description

    ID of the newly created knowledge base table.

  • Name
    tableName
    Type
    string
    Description

    Name of the created table.

  • Name
    filesInserted
    Type
    integer
    Description

    Number of files successfully inserted as rows.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

  curl --request POST \
    --url 'https://api.autessa.com/clients/autessadb/create-knowledge-base?resourceId=V1StGXR8Z5' \
    --header 'Content-Type: application/json' \
    --header 'Authorization: your_api_key' \
    --data '{
      "tableName": "Product Docs",
      "files": [
        {
          "fullPath": "docs/getting-started.pdf",
          "s3Uri": "s3://autessa-files/uploads/getting-started.pdf"
        },
        {
          "fullPath": "docs/api-reference.pdf",
          "s3Uri": "s3://autessa-files/uploads/api-reference.pdf"
        }
      ]
    }'
JSON
{
  "tableId": "kzT9pLm3Qw",
  "tableName": "Product Docs",
  "filesInserted": 2,
  "errors": []
}

Data Manipulation​

Insert Row POST/insert​

Inserts a new row into a table.

Permission Required: WRITE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table (same as resourceId).

  • Name
    values
    Type
    object
    Description

    Column values to insert. Keys are column names, values are AutessaDbColumnValue objects.

Response​

  • Name
    insertedId
    Type
    integer
    Description

    The ID of the newly inserted row.

  • Name
    newRow
    Type
    object
    Description

    The complete inserted row data with all column values.

  • Name
    computationStatus
    Type
    string
    Description

    "COMPUTING" if computed fields are being calculated in the background.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

  curl --request POST \
    --url 'https://api.autessa.com/clients/autessadb/insert?resourceId=V1StGXR8Z5' \
    --header 'Content-Type: application/json' \
    --header 'Authorization: your_api_key' \
    --data '{
      "tableId": "V1StGXR8Z5",
      "values": {
        "name": {
          "columnType": "SHORT_TEXT",
          "textValue": "John Doe"
        },
        "age": {
          "columnType": "INTEGER",
          "integerValue": 30
        },
        "email": {
          "columnType": "SHORT_TEXT",
          "textValue": "john@example.com"
        }
      }
    }'
JSON
{
  "insertedId": 12345,
  "newRow": {
    "name": {
      "columnType": "SHORT_TEXT",
      "textValue": "John Doe"
    },
    "age": {
      "columnType": "INTEGER",
      "integerValue": 30
    },
    "email": {
      "columnType": "SHORT_TEXT",
      "textValue": "john@example.com"
    }
  },
  "errors": []
}

Update Row POST/update​

Updates an existing row in a table. Only the specified columns will be updated.

Permission Required: WRITE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    rowId
    Type
    integer
    Description

    The ID of the row to update.

  • Name
    values
    Type
    object
    Description

    Column values to update. Only specified columns will be modified.

Response​

  • Name
    updatedId
    Type
    integer
    Description

    The ID of the updated row.

  • Name
    oldRow
    Type
    object
    Description

    Row data before the update.

  • Name
    newRow
    Type
    object
    Description

    Row data after the update.

  • Name
    computationStatus
    Type
    string
    Description

    "COMPUTING" if computed fields are being calculated.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/update?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "rowId": 12345,
    "values": {
      "age": {
        "columnType": "INTEGER",
        "integerValue": 31
      }
    }
  }'
JSON
{
  "updatedId": 12345,
  "oldRow": {
    "name": {
      "columnType": "SHORT_TEXT",
      "textValue": "John Doe"
    },
    "age": {
      "columnType": "INTEGER",
      "integerValue": 30
    }
  },
  "newRow": {
    "name": {
      "columnType": "SHORT_TEXT",
      "textValue": "John Doe"
    },
    "age": {
      "columnType": "INTEGER",
      "integerValue": 31
    }
  },
  "errors": []
}

Batch Update Rows POST/batch-update​

Updates multiple rows that match the specified WHERE conditions. All matching rows will be updated with the same values.

Permission Required: WRITE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    values
    Type
    object
    Description

    Column values to update for all matching rows.

  • Name
    whereGroups
    Type
    array<WhereGroupDto>
    Description

    Array of WHERE condition groups to identify rows to update.

  • Name
    groupsLogicalOperator
    Type
    string
    Description

    How to combine WHERE groups: "AND" or "OR". Defaults to "OR".

Response​

  • Name
    updatedCount
    Type
    integer
    Description

    Number of rows that were updated.

  • Name
    results
    Type
    array<BatchUpdateRowResult>
    Description

    Detailed results for each updated row (rowId, oldRow, newRow).

  • Name
    computationStatus
    Type
    string
    Description

    "COMPUTING" if computed fields are being calculated.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/batch-update?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "values": {
      "status": {
        "columnType": "SINGLE_SELECT",
        "textValue": "active"
      }
    },
    "whereGroups": [
      {
        "logicalOperator": "AND",
        "conditions": [
          {
            "columnName": "age",
            "operator": "GREATER_THAN",
            "value": 25
          }
        ]
      }
    ]
  }'
JSON
{
  "updatedCount": 5,
  "results": [
    {
      "rowId": 12345,
      "oldRow": {...},
      "newRow": {...}
    },
    {
      "rowId": 12346,
      "oldRow": {...},
      "newRow": {...}
    }
  ],
  "errors": []
}

Delete Row POST/delete-row​

Deletes a single row from a table.

Permission Required: DELETE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    rowId
    Type
    integer
    Description

    The ID of the row to delete.

Response​

  • Name
    deletedId
    Type
    integer
    Description

    The ID of the deleted row.

  • Name
    oldRow
    Type
    object
    Description

    The deleted row data.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/delete-row?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "rowId": 12345
  }'
JSON
{
  "deletedId": 12345,
  "oldRow": {
    "name": {
      "columnType": "SHORT_TEXT",
      "textValue": "John Doe"
    },
    "age": {
      "columnType": "INTEGER",
      "integerValue": 30
    }
  },
  "errors": []
}

Batch Delete Rows POST/batch-delete​

Deletes multiple rows that match the specified WHERE conditions.

Permission Required: DELETE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    whereGroups
    Type
    array<WhereGroupDto>
    Description

    Array of WHERE condition groups to identify rows to delete.

  • Name
    groupsLogicalOperator
    Type
    string
    Description

    How to combine WHERE groups: "AND" or "OR". Defaults to "OR".

Response​

  • Name
    deletedCount
    Type
    integer
    Description

    Number of rows that were deleted.

  • Name
    results
    Type
    array<BatchDeleteRowResult>
    Description

    Detailed results for each deleted row (rowId, oldRow).

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/batch-delete?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "whereGroups": [
      {
        "logicalOperator": "AND",
        "conditions": [
          {
            "columnName": "status",
            "operator": "EQUALS",
            "value": "inactive"
          },
          {
            "columnName": "lastLogin",
            "operator": "IS_NULL"
          }
        ]
      }
    ]
  }'
JSON
{
  "deletedCount": 3,
  "results": [
    {
      "rowId": 12345,
      "oldRow": {...}
    },
    {
      "rowId": 12347,
      "oldRow": {...}
    },
    {
      "rowId": 12350,
      "oldRow": {...}
    }
  ],
  "errors": []
}

Bulk Operations​

The bulk endpoints write many rows in a single call — insert, update-by-id, and delete-by-id. Each returns a per-row result list so you can correlate individual outcomes, and each accepts mode fields that control failure handling and side effects.

Bulk writes suppress table triggers by default — a deliberate divergence from single-row writes, whose triggers always fire. Bulk loads are typically ingestion where firing per-row triggers thousands of times is rarely intended. Set triggerMode to "PER_ROW" or "BATCH_CONTEXT" to opt in.

Common mode fields (all optional):

  • Name
    atomicity
    Type
    string
    Description

    "ALL_OR_NOTHING" (default) writes the whole call as one transaction — if any row fails a structural check, nothing is written. "BEST_EFFORT_PER_CHUNK" writes in chunks; a failing chunk is reported per-row and skipped while earlier chunks stay committed.

  • Name
    triggerMode
    Type
    string
    Description

    "SUPPRESS" (default), "PER_ROW", or "BATCH_CONTEXT". See the note above.

  • Name
    indexingMode
    Type
    string
    Description

    "IMMEDIATE" (default), "DEFERRED", or "SKIP" — when semantic-search indexing of the written rows happens. (Insert and update only.)

  • Name
    computeMode
    Type
    string
    Description

    "IMMEDIATE" (default), "DEFERRED", or "SKIP" — when computed fields are calculated. (Insert and update only.)

The number of rows per bulk call is capped (a generous first-party limit). Requests above the cap are rejected; split very large loads across multiple calls. Read and aggregate endpoints are additionally rate-limited per company (see Rate Limits).

Bulk Insert Rows POST/bulk-insert​

Inserts many rows into a table in a single call.

Permission Required: WRITE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    rows
    Type
    array<object>
    Description

    List of rows to insert. Each entry is a column-name → column-value map, the same shape as a single insert's values.

  • Name
    atomicity
    Type
    string
    Description

    See common mode fields above.

  • Name
    indexingMode
    Type
    string
    Description

    See common mode fields above.

  • Name
    computeMode
    Type
    string
    Description

    See common mode fields above.

  • Name
    triggerMode
    Type
    string
    Description

    See common mode fields above.

Response​

  • Name
    insertedCount
    Type
    integer
    Description

    Number of rows actually written.

  • Name
    results
    Type
    array<BulkInsertRowResult>
    Description

    One entry per input row: { inputIndex, insertedId, newRow, errors }. inputIndex is the row's position in the request so you can correlate; on failure errors is populated and insertedId is null.

  • Name
    computationStatus
    Type
    string
    Description

    "COMPUTING" if computed fields are being calculated in the background.

  • Name
    errors
    Type
    array<string>
    Description

    Top-level errors when the whole call was rejected (e.g. an ALL_OR_NOTHING validation failure).

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/bulk-insert?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "rows": [
      { "name": { "columnType": "SHORT_TEXT", "textValue": "Ada" } },
      { "name": { "columnType": "SHORT_TEXT", "textValue": "Grace" } }
    ],
    "atomicity": "ALL_OR_NOTHING"
  }'
JSON
{
  "insertedCount": 2,
  "results": [
    { "inputIndex": 0, "insertedId": 12345, "newRow": {...}, "errors": [] },
    { "inputIndex": 1, "insertedId": 12346, "newRow": {...}, "errors": [] }
  ],
  "computationStatus": null,
  "errors": []
}

Bulk Update Rows By IDs POST/bulk-update-by-ids​

Updates many rows by id in a single call. Each update is a partial patch — only the columns you supply change.

Permission Required: WRITE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    updates
    Type
    array<object>
    Description

    List of per-row updates. Each entry is { "id": <rowId>, "values": { ... } }, where values is a partial column-name → column-value map.

  • Name
    atomicity
    Type
    string
    Description

    See common mode fields above.

  • Name
    indexingMode
    Type
    string
    Description

    See common mode fields above.

  • Name
    computeMode
    Type
    string
    Description

    See common mode fields above.

  • Name
    triggerMode
    Type
    string
    Description

    See common mode fields above.

Response​

  • Name
    updatedCount
    Type
    integer
    Description

    Number of rows actually written.

  • Name
    results
    Type
    array<BulkUpdateRowByIdResult>
    Description

    One entry per input row: { inputIndex, updatedId, oldRow, newRow, errors }. An id that is not found or outside your access is reported per-row in errors.

  • Name
    computationStatus
    Type
    string
    Description

    "COMPUTING" if computed fields are being recalculated in the background.

  • Name
    errors
    Type
    array<string>
    Description

    Top-level errors when the whole call was rejected.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/bulk-update-by-ids?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "updates": [
      { "id": 12345, "values": { "status": { "columnType": "SINGLE_SELECT", "textValue": "done" } } },
      { "id": 12346, "values": { "status": { "columnType": "SINGLE_SELECT", "textValue": "open" } } }
    ]
  }'
JSON
{
  "updatedCount": 2,
  "results": [
    { "inputIndex": 0, "updatedId": 12345, "oldRow": {...}, "newRow": {...}, "errors": [] },
    { "inputIndex": 1, "updatedId": 12346, "oldRow": {...}, "newRow": {...}, "errors": [] }
  ],
  "errors": []
}

Bulk Delete Rows By IDs POST/bulk-delete-by-ids​

Deletes many rows by id in a single call. Only atomicity and triggerMode apply (there is nothing to index or compute on a delete).

Permission Required: DELETE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    ids
    Type
    array<integer>
    Description

    List of row ids to delete.

  • Name
    atomicity
    Type
    string
    Description

    See common mode fields above.

  • Name
    triggerMode
    Type
    string
    Description

    See common mode fields above.

Response​

  • Name
    deletedCount
    Type
    integer
    Description

    Number of rows actually removed.

  • Name
    results
    Type
    array<BulkDeleteRowByIdResult>
    Description

    One entry per input id: { inputIndex, deletedId, errors }. An id that is not found or outside your access is reported per-row in errors.

  • Name
    errors
    Type
    array<string>
    Description

    Top-level errors when the whole call was rejected.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/bulk-delete-by-ids?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "ids": [12345, 12346, 12347]
  }'
JSON
{
  "deletedCount": 3,
  "results": [
    { "inputIndex": 0, "deletedId": 12345, "errors": [] },
    { "inputIndex": 1, "deletedId": 12346, "errors": [] },
    { "inputIndex": 2, "deletedId": 12347, "errors": [] }
  ],
  "errors": []
}

Data Retrieval​

Get Table Data POST/get-data​

Retrieves paginated data from a table.

Permission Required: READ

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    orderBy
    Type
    array<OrderBy>
    Description

    Sort terms in priority order. Each is { "columnName": "...", "direction": "ASC" | "DESC" } (direction defaults to DESC). Defaults to newest-updated first when omitted.

  • Name
    page
    Type
    integer
    Description

    Page number (1-based). Defaults to 1. Ignored when cursor is set.

  • Name
    pageSize
    Type
    integer
    Description

    Number of records per page. Defaults to 50. Maximum 100.

  • Name
    cursor
    Type
    string
    Description

    Opaque cursor from a prior response's nextCursor, for efficient seek pagination through large tables. When set, page is ignored and the same orderBy must be reused. A cursor is bound to the sort that produced it.

  • Name
    includeTotal
    Type
    boolean
    Description

    Whether to compute totalRows/totalPages. Offset requests default to true; cursor requests default to false (set true to force the count).

Response​

  • Name
    schema
    Type
    AutessaDbSchema
    Description

    The table schema definition.

  • Name
    rows
    Type
    array<TableRowDto>
    Description

    Array of table rows with column data and metadata.

  • Name
    currentPage
    Type
    integer
    Description

    Current page number.

  • Name
    pageSize
    Type
    integer
    Description

    Number of rows per page.

  • Name
    totalRows
    Type
    integer
    Description

    Total number of rows matching the request. null on a cursor request unless includeTotal was set.

  • Name
    totalPages
    Type
    integer
    Description

    Total number of pages. null on a cursor request unless includeTotal was set.

  • Name
    nextCursor
    Type
    string
    Description

    Cursor to fetch the next page; null when there are no more rows.

  • Name
    hasMore
    Type
    boolean
    Description

    Whether another page exists beyond this one.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/get-data?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "page": 1,
    "pageSize": 50
  }'
JSON
{
  "schema": {
    "tableName": "users",
    "columnDefinitions": [
      {
        "columnName": "name",
        "columnType": "SHORT_TEXT",
        "required": true
      },
      {
        "columnName": "age",
        "columnType": "INTEGER",
        "required": false
      }
    ],
    "dbType": "DEFAULT"
  },
  "rows": [
    {
      "id": 12345,
      "columnData": {
        "name": {
          "columnType": "SHORT_TEXT",
          "textValue": "John Doe"
        },
        "age": {
          "columnType": "INTEGER",
          "integerValue": 30
        }
      },
      "createdAt": "2025-01-29T10:00:00",
      "updatedAt": "2025-01-29T15:30:00"
    }
  ],
  "currentPage": 1,
  "pageSize": 50,
  "totalRows": 150,
  "totalPages": 3,
  "errors": []
}

Query Table Data POST/query​

Queries table data with WHERE conditions and pagination.

Permission Required: READ

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    whereGroups
    Type
    array<WhereGroupDto>
    Description

    Array of WHERE condition groups for filtering.

  • Name
    groupsLogicalOperator
    Type
    string
    Description

    How to combine WHERE groups: "AND" or "OR". Defaults to "OR".

  • Name
    orderBy
    Type
    array<OrderBy>
    Description

    Sort terms in priority order. Each is { "columnName": "...", "direction": "ASC" | "DESC" } (direction defaults to DESC).

  • Name
    page
    Type
    integer
    Description

    Page number (1-based). Defaults to 1. Ignored when cursor is set.

  • Name
    pageSize
    Type
    integer
    Description

    Records per page. Defaults to 50. Maximum 100.

  • Name
    cursor
    Type
    string
    Description

    Opaque cursor from a prior response's nextCursor for seek pagination. When set, page is ignored and the same orderBy must be reused.

  • Name
    includeTotal
    Type
    boolean
    Description

    Whether to compute totalRows/totalPages. Offset requests default to true; cursor requests default to false.

Response​

Same structure as Get Table Data, but filtered by WHERE conditions — including nextCursor / hasMore for cursor pagination and nullable totalRows / totalPages on cursor requests.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/query?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "whereGroups": [
      {
        "logicalOperator": "AND",
        "conditions": [
          {
            "columnName": "age",
            "operator": "GREATER_THAN_OR_EQUAL",
            "value": 18
          },
          {
            "columnName": "status",
            "operator": "EQUALS",
            "value": "active"
          }
        ]
      }
    ],
    "page": 1,
    "pageSize": 50
  }'
JSON
{
  "schema": {...},
  "rows": [
    {
      "id": 12345,
      "columnData": {...},
      "createdAt": "2025-01-29T10:00:00",
      "updatedAt": "2025-01-29T15:30:00"
    }
  ],
  "currentPage": 1,
  "pageSize": 50,
  "totalRows": 25,
  "totalPages": 1,
  "errors": []
}

Join Query POST/join-query​

Performs JOIN operations across multiple tables with optional WHERE conditions.

Permission Required: READ (on all tables in the join)

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the main/left table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the main/left table.

  • Name
    joins
    Type
    array<JoinConditionDto>
    Description

    Array of tables to join with and their join conditions.

  • Name
    whereGroups
    Type
    array<WhereGroupDto>
    Description

    Optional WHERE conditions applied after the join.

  • Name
    groupsLogicalOperator
    Type
    string
    Description

    How to combine WHERE groups: "AND" or "OR". Defaults to "OR".

  • Name
    orderBy
    Type
    array<OrderBy>
    Description

    Sort terms (main-table columns) in priority order. Each is { "columnName": "...", "direction": "ASC" | "DESC" }.

  • Name
    page
    Type
    integer
    Description

    Page number. Defaults to 1. Ignored when cursor is set.

  • Name
    pageSize
    Type
    integer
    Description

    Records per page. Defaults to 50. Maximum 100.

  • Name
    cursor
    Type
    string
    Description

    Opaque cursor from a prior response's nextCursor for seek pagination. When set, page is ignored and the same orderBy must be reused.

  • Name
    includeTotal
    Type
    boolean
    Description

    Whether to compute totalRows/totalPages. Offset requests default to true; cursor requests default to false.

Response​

Includes nextCursor / hasMore for cursor pagination; totalRows / totalPages are null on a cursor request unless includeTotal was set.

  • Name
    mainSchema
    Type
    AutessaDbSchema
    Description

    Schema of the main/source table.

  • Name
    joinedSchemas
    Type
    object
    Description

    Map of joined table ID to schema. Keys are the joined tables' raw numeric IDs.

  • Name
    rows
    Type
    array<JoinedTableRowDto>
    Description

    Joined rows with columns prefixed by table name. Each row includes sourceTableId (string), sourceRowId (integer), columnData, createdAt, and updatedAt.

  • Name
    currentPage
    Type
    integer
    Description

    Current page number.

  • Name
    pageSize
    Type
    integer
    Description

    Number of rows per page.

  • Name
    totalRows
    Type
    integer
    Description

    Total number of joined rows.

  • Name
    totalPages
    Type
    integer
    Description

    Total number of pages.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/join-query?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "joins": [
      {
        "rightTableId": "3oPtLQmZ7v",
        "joinType": "INNER",
        "leftColumnName": "user_id",
        "rightColumnName": "id"
      }
    ],
    "whereGroups": [
      {
        "logicalOperator": "AND",
        "conditions": [
          {
            "columnName": "status",
            "operator": "EQUALS",
            "value": "active"
          }
        ]
      }
    ]
  }'
JSON
{
  "mainSchema": {...},
  "joinedSchemas": {
    "790": {...}
  },
  "rows": [
    {
      "sourceTableId": "V1StGXR8Z5",
      "sourceRowId": 12345,
      "columnData": {
        "orders.order_id": {...},
        "orders.user_id": {...},
        "users.id": {...},
        "users.name": {...}
      },
      "createdAt": "2025-01-29T10:00:00",
      "updatedAt": "2025-01-29T15:30:00"
    }
  ],
  "currentPage": 1,
  "totalRows": 42,
  "totalPages": 1,
  "errors": []
}

Aggregate POST/aggregate​

Runs a grouped aggregation over a table: filter, group by up to a few columns, compute aggregates, optionally filter groups and sort, and return a capped set of groups.

Permission Required: READ

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    whereGroups
    Type
    array<WhereGroupDto>
    Description

    Optional pre-aggregation filter (same shape as query).

  • Name
    groupsLogicalOperator
    Type
    string
    Description

    How to combine WHERE groups: "AND" or "OR". Defaults to "OR".

  • Name
    groupBy
    Type
    array<string>
    Description

    Columns to group by (a small maximum applies). Omit to aggregate the whole filtered set into a single group.

  • Name
    aggregates
    Type
    array<AggregateSpec>
    Description

    The aggregates to compute. Each is { "function": "COUNT" | "SUM" | "AVG" | "MIN" | "MAX", "column": "...", "alias": "..." }. column may be omitted for COUNT (counts rows). alias is required, must be unique, and is how the value is returned and referenced by having / orderBy.

  • Name
    having
    Type
    array<HavingCondition>
    Description

    Post-aggregation filters on computed aggregates, referenced by alias. Each is { "alias": "...", "operator": "=" | "!=" | ">" | "<" | ">=" | "<=", "value": <number> }. Multiple conditions are ANDed.

  • Name
    orderBy
    Type
    array<OrderBy>
    Description

    Sort by a groupBy column or an aggregate alias.

  • Name
    limit
    Type
    integer
    Description

    Maximum number of groups to return (clamped to the configured maximum).

Response​

  • Name
    groups
    Type
    array<AggregateGroup>
    Description

    One entry per group: { "key": { <groupByColumn>: <value> }, "values": { <alias>: <number> } }. key is empty when there is no groupBy.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

Columns hidden from your access are treated as not existing, and columns you may only see in masked form cannot be grouped or aggregated (the request is rejected). Aggregation is additionally rate-limited per company (see Rate Limits).

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/aggregate?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "groupBy": ["status"],
    "aggregates": [
      { "function": "COUNT", "alias": "count" },
      { "function": "AVG", "column": "age", "alias": "avg_age" }
    ],
    "orderBy": [{ "columnName": "count", "direction": "DESC" }]
  }'
JSON
{
  "groups": [
    { "key": { "status": "active" }, "values": { "count": 120, "avg_age": 34.2 } },
    { "key": { "status": "inactive" }, "values": { "count": 30, "avg_age": 41.7 } }
  ],
  "errors": []
}

Get Single Row POST/get-single-row​

Retrieves a single row by ID with pre-signed URLs for FILE/IMAGE columns.

Permission Required: READ

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    rowId
    Type
    integer
    Description

    The ID of the row to retrieve.

Response​

  • Name
    schema
    Type
    AutessaDbSchema
    Description

    The table schema.

  • Name
    row
    Type
    TableRowDto
    Description

    Single row with presigned URLs for FILE/IMAGE columns (10-minute expiry).

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/get-single-row?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "rowId": 12345
  }'
JSON
{
  "schema": {...},
  "row": {
    "id": 12345,
    "columnData": {
      "name": {
        "columnType": "SHORT_TEXT",
        "textValue": "John Doe"
      },
      "avatar": {
        "columnType": "IMAGE",
        "filePath": "s3://bucket/avatar.jpg",
        "presignedUrl": "https://s3.amazonaws.com/..."
      }
    },
    "createdAt": "2025-01-29T10:00:00",
    "updatedAt": "2025-01-29T15:30:00"
  },
  "errors": []
}

Search Table POST/search​

Performs semantic vector search on a table column using embeddings. Searches use different strategies based on column type (SHORT_TEXT vs LONG_TEXT).

Permission Required: READ

Note: Columns must be indexed before they can be searched. Use /index-record to index rows.

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    query
    Type
    string
    Description

    The search query text.

  • Name
    columnName
    Type
    string
    Description

    The column name to search within.

  • Name
    limit
    Type
    integer
    Description

    Maximum number of results. Default: 10. Maximum: 100.

  • Name
    scoreThreshold
    Type
    number
    Description

    Minimum similarity score (0.0 to 1.0). Default: 0.0.

  • Name
    page
    Type
    integer
    Description

    Page number (1-based). Default: 1.

  • Name
    includeDetails
    Type
    boolean
    Description

    Whether to include detailed match information. Default: false.

Response​

  • Name
    schema
    Type
    AutessaDbSchema
    Description

    The table schema.

  • Name
    results
    Type
    array<SearchResult>
    Description

    Search results ordered by relevance (highest score first).

  • Name
    totalResults
    Type
    integer
    Description

    Total number of results found (before pagination).

  • Name
    currentPage
    Type
    integer
    Description

    Current page number.

  • Name
    totalPages
    Type
    integer
    Description

    Total number of pages.

  • Name
    metadata
    Type
    SearchMetadata
    Description

    Search metadata including query, column, strategy, execution time.

  • Name
    errors
    Type
    array<string>
    Description

    Array of error messages if any occurred.

  curl --request POST \
    --url 'https://api.autessa.com/clients/autessadb/search?resourceId=V1StGXR8Z5' \
    --header 'Content-Type: application/json' \
    --header 'Authorization: your_api_key' \
    --data '{
      "tableId": "V1StGXR8Z5",
      "query": "machine learning engineer",
      "columnName": "job_description",
      "limit": 10,
      "scoreThreshold": 0.7
    }'
JSON
{
  "schema": {...},
  "results": [
    {
      "recordId": 12345,
      "score": 0.92,
      "rank": 1,
      "contentHash": "hash_abc",
      "rowData": {
        "job_title": {
          "columnType": "SHORT_TEXT",
          "textValue": "Senior ML Engineer"
        },
        "job_description": {
          "columnType": "LONG_TEXT",
          "textValue": "We are looking for..."
        }
      },
      "createdAt": "2025-01-29T10:00:00",
      "updatedAt": "2025-01-29T15:30:00",
      "details": {
        "embedType": "FULL",
        "allMatches": [
          {
            "embedType": "FULL",
            "score": 0.92
          }
        ]
      }
    }
  ],
  "totalResults": 25,
  "currentPage": 1,
  "totalPages": 3,
  "metadata": {
    "query": "machine learning engineer",
    "columnName": "job_description",
    "columnType": "LONG_TEXT",
    "searchStrategy": "HYBRID",
    "targetEmbeddingTypes": ["FULL", "CHUNK"],
    "executionTimeMs": 45
  },
  "errors": []
}

File Upload​

Generate Upload Link POST/generate-upload-link​

Generates a pre-signed S3 upload URL for file/image/video columns. Upload your file to the returned URL, then use the S3 URI in insert/update operations.

Permission Required: WRITE

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    fileType
    Type
    string
    Description

    File extension. Supported: DOCX, DOC, PDF, PPTX, XLSX, XLS, TXT, JSON, YAML, YML, XML, HTML, HTM, CSV, EML, MD, MARKDOWN, PNG, JPG, JPEG, GIF, WEBP, AVIF, BMP, ICO, TIFF, TIF, HEIC, HEIF, MP4, AVI, MOV, WMV, FLV, MKV, WEBM, MPEG, MPG, MP3, M4A, WAV

  • Name
    columnName
    Type
    string
    Description

    The column name where the file will be stored.

Response​

  • Name
    uploadUrl
    Type
    string
    Description

    Pre-signed URL for uploading the file via PUT request.

  • Name
    s3Uri
    Type
    string
    Description

    S3 URI to use in insert/update requests.

  • Name
    expiresInSeconds
    Type
    integer
    Description

    Time in seconds until the upload URL expires.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/generate-upload-link?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "fileType": "PDF",
    "columnName": "resume"
  }'
JSON
{
  "uploadUrl": "https://s3.amazonaws.com/autessa-files/...",
  "s3Uri": "s3://autessa-files/uploads/resume-xyz.pdf",
  "expiresInSeconds": 3600,
  "errors": []
}
# Already done above

Indexing​

Index Record POST/index-record​

Indexes a row for semantic search. Creates vector embeddings for SHORT_TEXT and LONG_TEXT columns. Required before searching.

Permission Required: WRITE

Note: Indexing happens automatically on insert/update for most columns, but you can manually trigger it with this endpoint.

Query Parameters​

  • Name
    resourceId
    Type
    string
    Description

    The ID of the table.

Request Body​

  • Name
    tableId
    Type
    string
    Description

    The ID of the table.

  • Name
    rowId
    Type
    integer
    Description

    The ID of the row to index.

Response​

  • Name
    recordId
    Type
    integer
    Description

    The ID of the indexed record.

  • Name
    columnsIndexed
    Type
    integer
    Description

    Number of columns that were indexed.

  • Name
    vectorsCreated
    Type
    integer
    Description

    Total number of vectors created.

  • Name
    indexingDurationMs
    Type
    integer
    Description

    Time taken for indexing in milliseconds.

  • Name
    indexedColumns
    Type
    array<string>
    Description

    Names of columns that were indexed.

cURL
curl --request POST \
  --url 'https://api.autessa.com/clients/autessadb/index-record?resourceId=V1StGXR8Z5' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: your_api_key' \
  --data '{
    "tableId": "V1StGXR8Z5",
    "rowId": 12345
  }'
JSON
{
  "recordId": 12345,
  "columnsIndexed": 3,
  "vectorsCreated": 15,
  "indexingDurationMs": 234,
  "indexedColumns": [
    "job_title",
    "job_description",
    "requirements"
  ],
  "errors": []
}

Rate Limits​

Read and aggregation endpoints (get-data, query, join-query, aggregate) are rate-limited per company on a rolling per-minute and per-day basis. The ceiling is generous for normal first-party use; if you exceed it the request is rejected and you should retry after a short back-off. Write endpoints are governed by the per-call bulk row cap rather than a request-rate limit.

Column Types​

AutessaDB supports various column types with different features:

  • Name
    SHORT_TEXT
    Description

    Short text (max 32,000 chars). Vectorization enabled for semantic search.

  • Name
    LONG_TEXT
    Description

    Long text (max 128,000 chars). Vectorization enabled for semantic search.

  • Name
    FILE
    Description

    File attachment. Use /generate-upload-link to upload.

  • Name
    IMAGE
    Description

    Image file (PNG, JPG, JPEG, GIF, WEBP, AVIF, BMP, ICO, TIFF, TIF, HEIC, HEIF). Every format except TIFF/TIF and HEIC/HEIF renders natively in an <img> tag, so you can point one at the cell's presignedUrl directly; for TIFF and HEIC offer a download instead, since most browsers will not paint them. Animated GIF and WEBP are stored and served intact and animate in the browser, but agent/LLM extraction reads the first frame only. SVG is not an IMAGE type — it is an executable document, so it belongs in a FILE column. Use /generate-upload-link to upload.

  • Name
    VIDEO
    Description

    Video file (MP4, AVI, MOV, etc.). Use /generate-upload-link to upload.

  • Name
    INTEGER
    Description

    Integer number.

  • Name
    FLOAT
    Description

    Floating point number.

  • Name
    BOOLEAN
    Description

    True/False value.

  • Name
    SINGLE_SELECT
    Description

    Single selection from predefined options.

  • Name
    MULTI_SELECT
    Description

    Multiple selections from predefined options.

  • Name
    DATETIME
    Description

    Legacy, read-only date/time type. Existing DATETIME columns (and the built-in created_at/updated_at) still read back their value, but new columns cannot be created with it — store timestamps as SHORT_TEXT holding UTC ISO-8601 strings (e.g. 2026-07-15T14:30:00Z) instead.

Append-Only Tables​

A table can be configured as append-only (immutable / audit-grade): rows may be inserted and read, but never updated or deleted. When a table is append-only, every write beyond insert is rejected for all callers — update, batch-update, bulk-update-by-ids, delete-row, batch-delete, and bulk-delete-by-ids all return an error. This makes append-only tables well suited to audit trails and event logs where records must be tamper-evident.

The schema returned on every read call carries an appendOnly boolean so your app can tell whether a table is immutable before offering edit or delete actions. Append-only is a one-way setting — once on, it cannot be turned off — and is configured when the table is created (via the poweruser Tables API or the builder), not through this row-level API.

Indexed Columns​

Columns can carry an equality index for faster filtering in query / join-query / aggregate. INTEGER, FLOAT, BOOLEAN, SINGLE_SELECT, and foreign-key columns are always indexed. SHORT_TEXT columns can opt in — once a SHORT_TEXT column is indexed, its values are length-capped to 2000 characters. LONG_TEXT, MULTI_SELECT, and media columns cannot be indexed.

Each column definition in a returned schema carries an indexed boolean. Indexes are configured at table creation or via a schema update (see the poweruser Tables API); on a large table a newly requested index builds in the background and becomes usable once its build finishes.

Column Value Format​

Each column value is an object with the column type and appropriate value field:

{
  "columnType": "SHORT_TEXT",
  "textValue": "Hello world"
}

WHERE Conditions​

WhereGroupDto​

  • Name
    logicalOperator
    Type
    string
    Description

    How to combine conditions within this group: "AND" or "OR"

  • Name
    conditions
    Type
    array<WhereConditionDto>
    Description

    List of conditions in this group

WhereConditionDto​

  • Name
    columnName
    Type
    string
    Description

    Column to filter on

  • Name
    operator
    Type
    string
    Description

    Comparison operator (see below)

  • Name
    value
    Type
    any
    Description

    Value to compare against (not needed for IS_NULL/IS_NOT_NULL)

Supported Operators​

  • Name
    EQUALS
    Description

    Exact match (=)

  • Name
    NOT_EQUALS
    Description

    Not equal (!=)

  • Name
    GREATER_THAN
    Description

    Greater than (>)

  • Name
    LESS_THAN
    Description

    Less than (<)

  • Name
    GREATER_THAN_OR_EQUAL
    Description

    Greater than or equal (>=)

  • Name
    LESS_THAN_OR_EQUAL
    Description

    Less than or equal (<=)

  • Name
    IN
    Description

    Value in list (value must be an array)

  • Name
    NOT_IN
    Description

    Value not in list (value must be an array)

  • Name
    IS_NULL
    Description

    Value is null (no value needed)

  • Name
    IS_NOT_NULL
    Description

    Value is not null (no value needed)

  • Name
    CONTAINS
    Description

    String contains substring

  • Name
    STARTS_WITH
    Description

    String starts with

  • Name
    ENDS_WITH
    Description

    String ends with

These 13 operators are the complete set — the query builder rejects anything else. The same operators (and per-column-type support rules) are documented in the Poweruser AutessaDB reference.

WHERE Examples​

{
  "whereGroups": [
    {
      "logicalOperator": "AND",
      "conditions": [
        {
          "columnName": "age",
          "operator": "GREATER_THAN",
          "value": 18
        }
      ]
    }
  ]
}

JOIN Operations​

JoinConditionDto​

  • Name
    rightTableId
    Type
    string
    Description

    The table to join with

  • Name
    joinType
    Type
    string
    Description

    Type of join: "INNER", "LEFT", "RIGHT". Defaults to "INNER".

  • Name
    leftColumnName
    Type
    string
    Description

    Column from the main/left table

  • Name
    rightColumnName
    Type
    string
    Description

    Column from the right table to join on

JOIN Examples​

{
  "tableId": "V1StGXR8Z5",
  "joins": [
    {
      "rightTableId": "3oPtLQmZ7v",
      "joinType": "INNER",
      "leftColumnName": "user_id",
      "rightColumnName": "id"
    }
  ]
}

Complete Examples​

Create and Search Records​

JavaScript
// 1. Insert a record
const insertResp = await fetch(
  'https://api.autessa.com/clients/autessadb/insert?resourceId=V1StGXR8Z5',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'your_api_key'
    },
    body: JSON.stringify({
      tableId: 'V1StGXR8Z5',
      values: {
        job_title: {
          columnType: 'SHORT_TEXT',
          textValue: 'Senior Machine Learning Engineer'
        },
        job_description: {
          columnType: 'LONG_TEXT',
          textValue: 'We are seeking an experienced ML engineer to join our team...'
        },
        salary: {
          columnType: 'INTEGER',
          integerValue: 150000
        }
      }
    })
  }
);

const { insertedId } = await insertResp.json();

// 2. Index the record for search
await fetch(
  'https://api.autessa.com/clients/autessadb/index-record?resourceId=V1StGXR8Z5',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'your_api_key'
    },
    body: JSON.stringify({
      tableId: 'V1StGXR8Z5',
      rowId: insertedId
    })
  }
);

// 3. Search for similar jobs
const searchResp = await fetch(
  'https://api.autessa.com/clients/autessadb/search?resourceId=V1StGXR8Z5',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'your_api_key'
    },
    body: JSON.stringify({
      tableId: 'V1StGXR8Z5',
      query: 'machine learning position',
      columnName: 'job_description',
      limit: 10,
      scoreThreshold: 0.7
    })
  }
);

const searchData = await searchResp.json();
console.log('Found', searchData.totalResults, 'matching jobs');
searchData.results.forEach(result => {
  console.log(`${result.rowData.job_title.textValue} - Score: ${result.score}`);
});

Batch Operations​

Python
import requests

headers = {
    'Content-Type': 'application/json',
    'Authorization': 'your_api_key'
}

# Batch update all inactive users
update_resp = requests.post(
    'https://api.autessa.com/clients/autessadb/batch-update?resourceId=V1StGXR8Z5',
    headers=headers,
    json={
        'tableId': 'V1StGXR8Z5',
        'values': {
            'status': {
                'columnType': 'SINGLE_SELECT',
                'textValue': 'archived'
            }
        },
        'whereGroups': [
            {
                'logicalOperator': 'AND',
                'conditions': [
                    {
                        'columnName': 'status',
                        'operator': 'EQUALS',
                        'value': 'inactive'
                    },
                    {
                        'columnName': 'lastLogin',
                        'operator': 'IS_NULL'
                    }
                ]
            }
        ]
    }
)

data = update_resp.json()
print(f"Updated {data['updatedCount']} users")

File Upload Workflow​

JavaScript
// 1. Generate upload link
const linkResp = await fetch(
  'https://api.autessa.com/clients/autessadb/generate-upload-link?resourceId=V1StGXR8Z5',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'your_api_key'
    },
    body: JSON.stringify({
      tableId: 'V1StGXR8Z5',
      fileType: 'PDF',
      columnName: 'resume'
    })
  }
);

const { uploadUrl, s3Uri } = await linkResp.json();

// 2. Upload file to S3
const fileData = await fetch('resume.pdf').then(r => r.blob());
await fetch(uploadUrl, {
  method: 'PUT',
  headers: { 'Content-Type': 'application/pdf' },
  body: fileData
});

// 3. Create record with file reference
await fetch(
  'https://api.autessa.com/clients/autessadb/insert?resourceId=V1StGXR8Z5',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'your_api_key'
    },
    body: JSON.stringify({
      tableId: 'V1StGXR8Z5',
      values: {
        name: {
          columnType: 'SHORT_TEXT',
          textValue: 'John Doe'
        },
        resume: {
          columnType: 'FILE',
          filePath: s3Uri
        }
      }
    })
  }
);

Best Practices​

Performance​

  • Use pagination for large datasets
  • Set appropriate scoreThreshold for search to filter low-quality results
  • Use batch operations for multiple updates/deletes
  • Index records immediately after insert for search availability

Security​

  • Configure minimal required permissions on API keys
  • Use environment variables for sensitive data
  • Rotate API keys regularly
  • Never expose API keys in client-side code

Data Integrity​

  • Always check the errors array in responses
  • Validate data before insertion
  • Use transactions for related operations
  • Monitor computationStatus for async operations

Search Optimization​

  • Index all searchable text columns
  • Use appropriate column types (SHORT_TEXT vs LONG_TEXT)
  • Set reasonable limit values
  • Use scoreThreshold to filter irrelevant results
  • Check metadata.executionTimeMs to monitor performance