Now that you understand API fundamentals, it's time to put them into practice. This article provides hands-on examples of the four core API operations—GET (retrieve), POST (create), PUT/PATCH (update), and DELETE (remove)—plus filtering, sorting, and pagination techniques for working with large datasets. By the end of this article, you'll be able to perform complete CRUD (Create, Read, Update, Delete) operations on your Tadabase data programmatically.

GET requests retrieve data from Tadabase without modifying it.

Get All Records

Basic request:

GET https://api.tadabase.io/api/v1/tables/{table_id}/records

cURL example:

curl -X GET "https://api.tadabase.io/api/v1/tables/abc123/records" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

JavaScript example:

const getRecords = async () => {
  const response = await fetch('https://api.tadabase.io/api/v1/tables/abc123/records', {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  return data;
};

getRecords()
  .then(data => {
    console.log('Total records:', data.total);
    data.data.forEach(record => {
      console.log('Record ID:', record.id);
      console.log('Field 1:', record.field_1);
    });
  })
  .catch(error => console.error('Error:', error));

Python example:

import requests

def get_records(table_id):
    url = f'https://api.tadabase.io/api/v1/tables/{table_id}/records'
    headers = {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    }

    response = requests.get(url, headers=headers)

    if response.status_code == 200:
        data = response.json()
        print(f"Total records: {data['total']}")
        for record in data['data']:
            print(f"Record ID: {record['id']}")
            print(f"Field 1: {record['field_1']}")
        return data
    else:
        print(f"Error: {response.status_code}")
        print(response.json())
        return None

# Usage
get_records('abc123')

Response format:

{
  "data": [
    {
      "id": "rec_abc123",
      "field_1": "John Smith",
      "field_2": "john@email.com",
      "field_3": "555-1234",
      "date_created": "2026-01-28T10:30:00Z",
      "date_modified": "2026-01-28T10:30:00Z"
    },
    {
      "id": "rec_def456",
      "field_1": "Jane Doe",
      "field_2": "jane@email.com",
      "field_3": "555-5678",
      "date_created": "2026-01-28T11:00:00Z",
      "date_modified": "2026-01-28T11:00:00Z"
    }
  ],
  "total": 2,
  "page": 1,
  "per_page": 50
}

Get Specific Record

Request:

GET https://api.tadabase.io/api/v1/tables/{table_id}/records/{record_id}

cURL example:

curl -X GET "https://api.tadabase.io/api/v1/tables/abc123/records/rec_xyz789" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

JavaScript example:

const getRecord = async (tableId, recordId) => {
  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records/${recordId}`;

  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return await response.json();
};

// Usage
getRecord('abc123', 'rec_xyz789')
  .then(data => console.log('Record:', data.data))
  .catch(error => console.error('Error:', error));

Response format:

{
  "data": {
    "id": "rec_xyz789",
    "field_1": "John Smith",
    "field_2": "john@email.com",
    "field_3": "555-1234",
    "date_created": "2026-01-28T10:30:00Z",
    "date_modified": "2026-01-28T10:30:00Z"
  }
}

POST requests create new records in Tadabase.

Create Single Record

Request:

POST https://api.tadabase.io/api/v1/tables/{table_id}/records

cURL example:

curl -X POST "https://api.tadabase.io/api/v1/tables/abc123/records" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "field_1": "Bob Johnson",
    "field_2": "bob@email.com",
    "field_3": "555-9999"
  }'

JavaScript example:

const createRecord = async (tableId, recordData) => {
  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records`;

  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(recordData)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`HTTP error! status: ${response.status}, message: ${error.message}`);
  }

  return await response.json();
};

// Usage
const newRecord = {
  field_1: 'Bob Johnson',
  field_2: 'bob@email.com',
  field_3: '555-9999'
};

createRecord('abc123', newRecord)
  .then(data => {
    console.log('Record created successfully');
    console.log('New record ID:', data.data.id);
  })
  .catch(error => console.error('Error:', error));

Python example:

import requests
import json

def create_record(table_id, record_data):
    url = f'https://api.tadabase.io/api/v1/tables/{table_id}/records'
    headers = {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    }

    response = requests.post(url, headers=headers, json=record_data)

    if response.status_code == 201:
        data = response.json()
        print('Record created successfully')
        print(f"New record ID: {data['data']['id']}")
        return data
    else:
        print(f"Error: {response.status_code}")
        print(response.json())
        return None

# Usage
new_record = {
    'field_1': 'Bob Johnson',
    'field_2': 'bob@email.com',
    'field_3': '555-9999'
}

create_record('abc123', new_record)

Response format:

{
  "data": {
    "id": "rec_ghi789",
    "field_1": "Bob Johnson",
    "field_2": "bob@email.com",
    "field_3": "555-9999",
    "date_created": "2026-01-28T12:00:00Z",
    "date_modified": "2026-01-28T12:00:00Z"
  },
  "message": "Record created successfully"
}

Creating Records with Different Field Types

Example with various field types:

{
  "text_field": "Sample text",
  "number_field": 123.45,
  "date_field": "2026-01-28",
  "datetime_field": "2026-01-28T10:30:00Z",
  "checkbox_field": true,
  "dropdown_field": "Option 1",
  "multi_select_field": ["Option 1", "Option 2"],
  "connection_field": "rec_related123",
  "email_field": "email@example.com",
  "phone_field": "555-1234",
  "currency_field": 99.99,
  "url_field": "https://example.com"
}

Important notes:

• Required fields: Must include all required fields
• Validation: Data must pass field validation rules
• Unique fields: Values must be unique if field requires it
• Connection fields: Use record ID of related record
• Date format: ISO 8601 format (YYYY-MM-DD)

PUT and PATCH requests update existing records.

PUT vs PATCH

PUT (full update):

• Replaces entire record
• Must include all fields
• Omitted fields set to null/empty

PATCH (partial update):

• Updates only specified fields
• Other fields remain unchanged
• Preferred for most updates

PATCH Request (Partial Update)

Request:

PATCH https://api.tadabase.io/api/v1/tables/{table_id}/records/{record_id}

cURL example:

curl -X PATCH "https://api.tadabase.io/api/v1/tables/abc123/records/rec_xyz789" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "field_2": "john.smith@newemail.com"
  }'

JavaScript example:

const updateRecord = async (tableId, recordId, updates) => {
  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records/${recordId}`;

  const response = await fetch(url, {
    method: 'PATCH',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(updates)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return await response.json();
};

// Usage - Update only email field
const updates = {
  field_2: 'john.smith@newemail.com'
};

updateRecord('abc123', 'rec_xyz789', updates)
  .then(data => {
    console.log('Record updated successfully');
    console.log('Updated record:', data.data);
  })
  .catch(error => console.error('Error:', error));

Python example:

import requests

def update_record(table_id, record_id, updates):
    url = f'https://api.tadabase.io/api/v1/tables/{table_id}/records/{record_id}'
    headers = {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    }

    response = requests.patch(url, headers=headers, json=updates)

    if response.status_code == 200:
        data = response.json()
        print('Record updated successfully')
        return data
    else:
        print(f"Error: {response.status_code}")
        print(response.json())
        return None

# Usage - Update only email field
updates = {
    'field_2': 'john.smith@newemail.com'
}

update_record('abc123', 'rec_xyz789', updates)

Response format:

{
  "data": {
    "id": "rec_xyz789",
    "field_1": "John Smith",
    "field_2": "john.smith@newemail.com",
    "field_3": "555-1234",
    "date_created": "2026-01-28T10:30:00Z",
    "date_modified": "2026-01-28T14:00:00Z"
  },
  "message": "Record updated successfully"
}

Bulk Update Example

Update multiple records:

const updateMultipleRecords = async (tableId, recordUpdates) => {
  const promises = recordUpdates.map(({recordId, updates}) =>
    updateRecord(tableId, recordId, updates)
  );

  return await Promise.all(promises);
};

// Usage
const updates = [
  { recordId: 'rec_123', updates: { field_1: 'New Value 1' } },
  { recordId: 'rec_456', updates: { field_1: 'New Value 2' } },
  { recordId: 'rec_789', updates: { field_1: 'New Value 3' } }
];

updateMultipleRecords('abc123', updates)
  .then(results => console.log('All records updated'))
  .catch(error => console.error('Error:', error));

DELETE requests permanently remove records from Tadabase.

Delete Single Record

Request:

DELETE https://api.tadabase.io/api/v1/tables/{table_id}/records/{record_id}

cURL example:

curl -X DELETE "https://api.tadabase.io/api/v1/tables/abc123/records/rec_xyz789" \
  -H "Authorization: Bearer YOUR_API_KEY"

JavaScript example:

const deleteRecord = async (tableId, recordId) => {
  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records/${recordId}`;

  const response = await fetch(url, {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return response.status === 204; // 204 = No Content (success)
};

// Usage
deleteRecord('abc123', 'rec_xyz789')
  .then(success => {
    if (success) {
      console.log('Record deleted successfully');
    }
  })
  .catch(error => console.error('Error:', error));

Python example:

import requests

def delete_record(table_id, record_id):
    url = f'https://api.tadabase.io/api/v1/tables/{table_id}/records/{record_id}'
    headers = {
        'Authorization': 'Bearer YOUR_API_KEY'
    }

    response = requests.delete(url, headers=headers)

    if response.status_code == 204:
        print('Record deleted successfully')
        return True
    else:
        print(f"Error: {response.status_code}")
        if response.content:
            print(response.json())
        return False

# Usage
delete_record('abc123', 'rec_xyz789')

Response:

• Status code: 204 (No Content)
• Empty response body
• Success = True, record deleted

Important warnings:

• Permanent: Deletion is permanent, cannot be undone
• Related records: Consider cascade effects on related data
• Backup: Always backup before bulk deletions
• Confirmation: Implement confirmation for delete operations

Bulk Delete Example

Delete multiple records:

const deleteMultipleRecords = async (tableId, recordIds) => {
  const promises = recordIds.map(recordId =>
    deleteRecord(tableId, recordId)
  );

  return await Promise.all(promises);
};

// Usage
const recordsToDelete = ['rec_123', 'rec_456', 'rec_789'];

deleteMultipleRecords('abc123', recordsToDelete)
  .then(results => {
    const successCount = results.filter(r => r).length;
    console.log(`${successCount} records deleted successfully`);
  })
  .catch(error => console.error('Error:', error));

Filter and sort results to retrieve exactly the data you need.

Basic Filtering

Filter by single field:

GET /tables/{table_id}/records?filter[field_1]=John Smith

Filter by multiple fields:

GET /tables/{table_id}/records?filter[field_1]=John&filter[field_3]=Active

JavaScript example:

const getFilteredRecords = async (tableId, filters) => {
  const params = new URLSearchParams();

  Object.keys(filters).forEach(field => {
    params.append(`filter[${field}]`, filters[field]);
  });

  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records?${params}`;

  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  return await response.json();
};

// Usage
const filters = {
  field_1: 'John Smith',
  field_4: 'Active'
};

getFilteredRecords('abc123', filters)
  .then(data => console.log('Filtered records:', data.data))
  .catch(error => console.error('Error:', error));

Advanced Filter Operators

Available operators:

• eq: Equals (default)
• ne: Not equals
• gt: Greater than
• gte: Greater than or equal
• lt: Less than
• lte: Less than or equal
• contains: Contains text
• starts: Starts with
• ends: Ends with
• in: In list

Examples: Greater than:

GET /tables/{table_id}/records?filter[amount][gt]=100

Contains text:

GET /tables/{table_id}/records?filter[name][contains]=smith

Date range:

GET /tables/{table_id}/records?filter[created_date][gte]=2026-01-01&filter[created_date][lte]=2026-01-31

In list:

GET /tables/{table_id}/records?filter[status][in]=Active,Pending

JavaScript example with operators:

const getRecordsWithFilters = async (tableId) => {
  const params = new URLSearchParams({
    'filter[amount][gt]': '100',
    'filter[status][in]': 'Active,Pending',
    'filter[name][contains]': 'smith'
  });

  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records?${params}`;

  const response = await fetch(url, {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  return await response.json();
};

Sorting

Sort ascending:

GET /tables/{table_id}/records?sort=field_1

Sort descending:

GET /tables/{table_id}/records?sort=-field_1

Multiple sort fields:

GET /tables/{table_id}/records?sort=-created_date,field_1

JavaScript example:

const getSortedRecords = async (tableId, sortFields) => {
  const params = new URLSearchParams({
    sort: sortFields.join(',')
  });

  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records?${params}`;

  const response = await fetch(url, {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  return await response.json();
};

// Usage - Sort by created_date (desc), then name (asc)
getSortedRecords('abc123', ['-created_date', 'field_1'])
  .then(data => console.log('Sorted records:', data.data))
  .catch(error => console.error('Error:', error));

Combining Filters and Sorting

Example:

GET /tables/{table_id}/records?filter[status]=Active&filter[amount][gt]=100&sort=-created_date&page=1&per_page=50

JavaScript complete example:

const getRecords = async (options) => {
  const {
    tableId,
    filters = {},
    sort = [],
    page = 1,
    perPage = 50
  } = options;

  const params = new URLSearchParams({
    page: page.toString(),
    per_page: perPage.toString()
  });

  // Add filters
  Object.keys(filters).forEach(field => {
    const value = filters[field];
    if (typeof value === 'object') {
      // Advanced filter with operator
      Object.keys(value).forEach(operator => {
        params.append(`filter[${field}][${operator}]`, value[operator]);
      });
    } else {
      // Simple equality filter
      params.append(`filter[${field}]`, value);
    }
  });

  // Add sorting
  if (sort.length > 0) {
    params.append('sort', sort.join(','));
  }

  const url = `https://api.tadabase.io/api/v1/tables/${tableId}/records?${params}`;

  const response = await fetch(url, {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  return await response.json();
};

// Usage
getRecords({
  tableId: 'abc123',
  filters: {
    status: 'Active',
    amount: { gt: '100', lt: '1000' }
  },
  sort: ['-created_date', 'field_1'],
  page: 1,
  perPage: 50
})
.then(data => console.log('Records:', data))
.catch(error => console.error('Error:', error));

Pagination handles large datasets efficiently.

Basic Pagination

Parameters:

• page: Page number (default: 1)
• per_page: Records per page (default: 50, max: 100)

Example:

GET /tables/{table_id}/records?page=2&per_page=25

Response includes pagination metadata:

{
  "data": [...],
  "total": 150,
  "page": 2,
  "per_page": 25,
  "total_pages": 6
}

Pagination Helper Functions

JavaScript example:

const getAllRecords = async (tableId, options = {}) => {
  let allRecords = [];
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const response = await getRecords({
      tableId,
      ...options,
      page,
      perPage: 100 // Maximum per page
    });

    allRecords = allRecords.concat(response.data);

    console.log(`Fetched page ${page} of ${response.total_pages}`);

    hasMore = page  {
  console.log(`Retrieved ${records.length} total records`);
})
.catch(error => console.error('Error:', error));

Python example:

def get_all_records(table_id, filters=None):
    all_records = []
    page = 1
    has_more = True

    while has_more:
        params = {
            'page': page,
            'per_page': 100
        }

        if filters:
            for field, value in filters.items():
                params[f'filter[{field}]'] = value

        url = f'https://api.tadabase.io/api/v1/tables/{table_id}/records'
        headers = {
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        }

        response = requests.get(url, headers=headers, params=params)

        if response.status_code == 200:
            data = response.json()
            all_records.extend(data['data'])

            print(f"Fetched page {page} of {data['total_pages']}")

            has_more = page 

Here's a complete example demonstrating all CRUD operations: JavaScript class:

class TadabaseAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.tadabase.io/api/v1';
  }

  async request(method, endpoint, data = null) {
    const options = {
      method,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    };

    if (data) {
      options.body = JSON.stringify(data);
    }

    const response = await fetch(`${this.baseUrl}${endpoint}`, options);

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`API error: ${response.status} - ${error.message}`);
    }

    // DELETE returns 204 with no content
    if (response.status === 204) {
      return { success: true };
    }

    return await response.json();
  }

  // GET - List records
  async getRecords(tableId, options = {}) {
    const params = new URLSearchParams();

    if (options.page) params.append('page', options.page);
    if (options.perPage) params.append('per_page', options.perPage);
    if (options.sort) params.append('sort', options.sort.join(','));

    if (options.filters) {
      Object.keys(options.filters).forEach(field => {
        params.append(`filter[${field}]`, options.filters[field]);
      });
    }

    const query = params.toString();
    const endpoint = `/tables/${tableId}/records${query ? '?' + query : ''}`;

    return await this.request('GET', endpoint);
  }

  // GET - Single record
  async getRecord(tableId, recordId) {
    return await this.request('GET', `/tables/${tableId}/records/${recordId}`);
  }

  // POST - Create record
  async createRecord(tableId, data) {
    return await this.request('POST', `/tables/${tableId}/records`, data);
  }

  // PATCH - Update record
  async updateRecord(tableId, recordId, data) {
    return await this.request('PATCH', `/tables/${tableId}/records/${recordId}`, data);
  }

  // DELETE - Delete record
  async deleteRecord(tableId, recordId) {
    return await this.request('DELETE', `/tables/${tableId}/records/${recordId}`);
  }
}

// Usage example
const api = new TadabaseAPI('YOUR_API_KEY');

// Create
const newRecord = await api.createRecord('abc123', {
  field_1: 'John Smith',
  field_2: 'john@email.com'
});
console.log('Created:', newRecord.data.id);

// Read - List
const records = await api.getRecords('abc123', {
  filters: { status: 'Active' },
  sort: ['-created_date'],
  page: 1,
  perPage: 50
});
console.log('Found:', records.total, 'records');

// Read - Single
const record = await api.getRecord('abc123', newRecord.data.id);
console.log('Record:', record.data);

// Update
const updated = await api.updateRecord('abc123', newRecord.data.id, {
  field_2: 'newemail@example.com'
});
console.log('Updated:', updated.data);

// Delete
await api.deleteRecord('abc123', newRecord.data.id);
console.log('Deleted successfully');

Follow these guidelines for reliable API operations:

• Error handling: Always handle errors gracefully
• Validation: Validate data before sending
• Pagination: Use pagination for large datasets
• Filtering: Filter server-side, not client-side
• Rate limits: Respect API rate limits
• Batch operations: Group related operations
• Logging: Log all API operations
• Testing: Test with various scenarios

Core API operations:

• GET: Retrieve records (list or single)
• POST: Create new records
• PATCH: Update existing records (partial)
• DELETE: Remove records permanently
• Filtering: Narrow results with filter operators
• Sorting: Order results by field values
• Pagination: Handle large datasets efficiently