Imports And Exports Api

Imports and Exports API

Learn how to trigger data imports and exports programmatically and monitor their progress using the Tadabase REST API (v1.1).

Imports API

List Import Templates

Get all import templates configured in your application:

GET /api/v1.1/{appId}/imports

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Query Parameters:
  limit=10           (optional)
  page=1             (optional)
  dataTableId=xyz    (optional filter by table)

Response

{
  "type": "success",
  "items": [
    {
      "id": "import_abc123",
      "name": "Customer CSV Import",
      "dataTableId": "lGArg7rmR6",
      "status": "Active"
    }
  ],
  "total_items": 5
}

Get Import Template Details

GET /api/v1.1/{appId}/imports/{importId}

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Trigger Import

POST /api/v1.1/{appId}/imports/{importId}/trigger

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret
  Content-Type: multipart/form-data

Body:
  file: [CSV file upload]
  or
  data_source: [URL or data]

Response

{
  "type": "success",
  "import_queue_id": "queue_import_xyz789",
  "msg": "Import started successfully"
}

Check Import Status

All Import Queues

GET /api/v1.1/{appId}/imports/queues

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Specific Import Queue

GET /api/v1.1/{appId}/imports/queues/{queueId}

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Import Status Response

{
  "type": "success",
  "items": [
    {
      "id": "queue_import_xyz789",
      "status": "Processing",
      "total_rows": 1000,
      "processed_rows": 750,
      "error_rows": 10,
      "created_at": "2024-01-27 14:00:00",
      "updated_at": "2024-01-27 14:05:30"
    }
  ]
}

Import Status Values

Status	Description
Queued	Waiting to start
Processing	Currently importing data
Complete	Import finished successfully
Failed	Import failed with errors

Exports API

List Export Templates

GET /api/v1.1/{appId}/exports

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Or using the templates endpoint:

GET /api/v1.1/{appId}/exports/templates

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Get Export Template Details

GET /api/v1.1/{appId}/exports/templates/{templateId}

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Trigger Export

POST /api/v1.1/{appId}/exports/templates/{templateId}/trigger

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret
  Content-Type: application/json

Body:
{
  "filters": {
    "condition": "AND",
    "items": [
      {
        "field_id": "status",
        "operator": "is",
        "val": "Active"
      }
    ]
  },
  "columns": ["field_slug1", "field_slug2"]
}

Response

{
  "type": "success",
  "export_queue_id": "queue_export_abc456",
  "msg": "Export started successfully"
}

Check Export Status

All Export Queues

GET /api/v1.1/{appId}/exports/queues

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Specific Export Queue

GET /api/v1.1/{appId}/exports/queues/{queueId}

Headers:
  X-Tadabase-App-id: your_app_id
  X-Tadabase-App-Key: your_app_key
  X-Tadabase-App-Secret: your_app_secret

Export Status Response

{
  "type": "success",
  "items": [
    {
      "id": "queue_export_abc456",
      "dataTable": {
        "id": "lGArg7rmR6",
        "name": "Customers"
      },
      "exportTemplate": {
        "id": "template_csv_001",
        "name": "CSV Customer Export"
      },
      "status": "Complete",
      "complete": 500,
      "total": 500,
      "start_date": "2024-01-27 14:00:00",
      "end_date": "2024-01-27 14:02:15",
      "download_url": "https://files.tadabase.io/exports/file.csv"
    }
  ]
}

Import with File Upload

async function uploadAndImport(appId, importId, file) {
  const formData = new FormData();
  formData.append('file', file);

  const response = await fetch(
    `https://api.tadabase.io/api/v1.1/${appId}/imports/${importId}/trigger`,
    {
      method: 'POST',
      headers: {
        'X-Tadabase-App-id': 'your_app_id',
        'X-Tadabase-App-Key': 'your_app_key',
        'X-Tadabase-App-Secret': 'your_app_secret'
      },
      body: formData
    }
  );

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

// Usage
const fileInput = document.getElementById('fileInput');
const file = fileInput.files[0];
const queueId = await uploadAndImport('74QY8R4ENB', 'import_abc123', file);
console.log('Import started:', queueId);

Monitor Import Progress

async function monitorImport(appId, queueId) {
  let status = 'Queued';

  while (status === 'Queued' || status === 'Processing') {
    await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds

    const response = await fetch(
      `https://api.tadabase.io/api/v1.1/${appId}/imports/queues/${queueId}`,
      {
        headers: {
          'X-Tadabase-App-id': 'your_app_id',
          'X-Tadabase-App-Key': 'your_app_key',
          'X-Tadabase-App-Secret': 'your_app_secret'
        }
      }
    );

    const data = await response.json();

    if (data.items && data.items.length > 0) {
      const importJob = data.items[0];
      status = importJob.status;

      console.log(
        `Import status: ${status} - ${importJob.processed_rows}/${importJob.total_rows} rows (${importJob.error_rows} errors)`
      );
    }
  }

  console.log(`Import ${status === 'Complete' ? 'completed successfully' : 'failed'}`);
  return status;
}

// Usage
const status = await monitorImport('74QY8R4ENB', 'queue_import_xyz789');

Trigger Export and Download

async function exportAndDownload(appId, templateId, filters = null) {
  // Trigger export
  const triggerResponse = await fetch(
    `https://api.tadabase.io/api/v1.1/${appId}/exports/templates/${templateId}/trigger`,
    {
      method: 'POST',
      headers: {
        'X-Tadabase-App-id': 'your_app_id',
        'X-Tadabase-App-Key': 'your_app_key',
        'X-Tadabase-App-Secret': 'your_app_secret',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ filters })
    }
  );

  const triggerData = await triggerResponse.json();
  const queueId = triggerData.export_queue_id;

  console.log('Export started:', queueId);

  // Wait for completion
  let status = 'Queued';
  let downloadUrl = null;

  while (status !== 'Complete' && status !== 'Failed') {
    await new Promise(resolve => setTimeout(resolve, 5000));

    const statusResponse = await fetch(
      `https://api.tadabase.io/api/v1.1/${appId}/exports/queues/${queueId}`,
      {
        headers: {
          'X-Tadabase-App-id': 'your_app_id',
          'X-Tadabase-App-Key': 'your_app_key',
          'X-Tadabase-App-Secret': 'your_app_secret'
        }
      }
    );

    const statusData = await statusResponse.json();

    if (statusData.items && statusData.items.length > 0) {
      const exportJob = statusData.items[0];
      status = exportJob.status;
      downloadUrl = exportJob.download_url;

      console.log(
        `Export status: ${status} - ${exportJob.complete}/${exportJob.total} records`
      );
    }
  }

  if (status === 'Complete') {
    console.log('Export complete. Download URL:', downloadUrl);
    return downloadUrl;
  } else {
    throw new Error('Export failed');
  }
}

// Usage
const filters = {
  condition: "AND",
  items: [
    { field_id: "status", operator: "is", val: "Active" }
  ]
};

const downloadUrl = await exportAndDownload('74QY8R4ENB', 'template_csv_001', filters);

// Open download URL
window.open(downloadUrl, '_blank');

Import/Export Manager Class

class ImportExportManager {
  constructor(appId, headers) {
    this.appId = appId;
    this.headers = headers;
    this.baseUrl = `https://api.tadabase.io/api/v1.1/${appId}`;
  }

  // Imports
  async listImports() {
    const response = await fetch(
      `${this.baseUrl}/imports`,
      { headers: this.headers }
    );
    return await response.json();
  }

  async triggerImport(importId, file) {
    const formData = new FormData();
    formData.append('file', file);

    const response = await fetch(
      `${this.baseUrl}/imports/${importId}/trigger`,
      {
        method: 'POST',
        headers: this.headers,
        body: formData
      }
    );

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

  async getImportStatus(queueId) {
    const response = await fetch(
      `${this.baseUrl}/imports/queues/${queueId}`,
      { headers: this.headers }
    );

    const data = await response.json();
    return data.items && data.items.length > 0 ? data.items[0] : null;
  }

  async waitForImport(queueId, maxWaitMinutes = 30) {
    const maxWaitTime = maxWaitMinutes * 60 * 1000;
    const startTime = Date.now();

    while (Date.now() - startTime  setTimeout(resolve, 5000));
    }

    return { success: false, error: 'Timeout' };
  }

  // Exports
  async listExports() {
    const response = await fetch(
      `${this.baseUrl}/exports`,
      { headers: this.headers }
    );
    return await response.json();
  }

  async triggerExport(templateId, options = {}) {
    const response = await fetch(
      `${this.baseUrl}/exports/templates/${templateId}/trigger`,
      {
        method: 'POST',
        headers: {
          ...this.headers,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(options)
      }
    );

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

  async getExportStatus(queueId) {
    const response = await fetch(
      `${this.baseUrl}/exports/queues/${queueId}`,
      { headers: this.headers }
    );

    const data = await response.json();
    return data.items && data.items.length > 0 ? data.items[0] : null;
  }

  async waitForExport(queueId, maxWaitMinutes = 30) {
    const maxWaitTime = maxWaitMinutes * 60 * 1000;
    const startTime = Date.now();

    while (Date.now() - startTime  setTimeout(resolve, 5000));
    }

    return { success: false, error: 'Timeout' };
  }

  async exportAndDownload(templateId, filters = null) {
    const queueId = await this.triggerExport(templateId, { filters });
    const result = await this.waitForExport(queueId);

    if (result.success) {
      return result.downloadUrl;
    } else {
      throw new Error(result.error);
    }
  }
}

// Usage
const manager = new ImportExportManager('74QY8R4ENB', headers);

// List available imports
const imports = await manager.listImports();
console.log('Available imports:', imports);

// Trigger import with progress
const importQueueId = await manager.triggerImport('import_abc123', file);
const importResult = await manager.waitForImport(importQueueId);

if (importResult.success) {
  console.log(`Imported ${importResult.status.processed_rows} rows`);
}

// Trigger export and get download URL
const downloadUrl = await manager.exportAndDownload('template_csv_001', {
  condition: "AND",
  items: [
    { field_id: "status", operator: "is", val: "Active" }
  ]
});

console.log('Download export:', downloadUrl);

Best Practices

1. Validate data before import: Check file format and data quality
2. Monitor import progress: Don't assume imports complete immediately
3. Handle import errors: Check error_rows count and investigate failures
4. Filter exports appropriately: Use filters to export only needed records
5. Set appropriate timeouts: Large imports/exports take time
6. Secure download URLs: Export download URLs may expire after a period
7. Test with small datasets first: Validate import templates with small files
8. Schedule large operations: Run large imports/exports during off-peak hours

Next Steps

Learn how to generate PDFs programmatically:

→ PDF Generation API

Discover how to create PDFs from records and templates via the API.