---
title: "How to Export Data from Tidio Knowledge Base: API, Limits & Gaps"
slug: how-to-export-data-from-tidio-knowledge-base-api-limits-gaps
date: 2026-08-14
author: Abdul
categories: [Tidio, Knowledge Base, Migration Guide]
excerpt: "Tidio has no built-in KB export. Extract Lyro data sources via the OpenAPI (Plus plan required, 60 req/min limit) or use workarounds for lower tiers."
tldr: "Tidio KB data can only be exported via the GET /lyro/data-sources API (Plus plan, $749/mo). No UI export exists, and folder-type sources return no content — only child Q&A pairs include actual text."
canonical: https://clonepartner.com/blog/how-to-export-data-from-tidio-knowledge-base-api-limits-gaps/
---

# How to Export Data from Tidio Knowledge Base: API, Limits & Gaps


# How to Export Data from Tidio Knowledge Base: API, Limits & Gaps

Tidio does not offer a one-click "Export Knowledge Base" button anywhere in its dashboard. If you need to extract your Lyro AI Agent data sources — Q&A pairs, scraped website content, imported PDFs — the only documented programmatic path is the **`GET /lyro/data-sources`** endpoint on the OpenAPI, gated to the **Plus plan ($749/mo) and above**. Teams on Free, Starter, or Growth plans have no API access to their knowledge base content. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

This guide covers every extraction method available, the real constraints you will hit, and what to do when the API is not an option. All API behaviors described here were verified against Tidio's published OpenAPI documentation and live Plus-tier account testing.

> [!NOTE]
> **Short answer:** Export Tidio knowledge base data via the `GET /lyro/data-sources` API endpoint (Plus plan required). There is no UI-based export. Budget for cursor-based pagination, rate limits of 60 req/min, and content gaps on folder-type sources. Last verified: against Tidio OpenAPI v1 documentation and live account behavior.

## What Tidio Calls a Knowledge Base

**Tidio's knowledge base is the data source layer that powers its Lyro AI Agent.** It is not a public-facing help center like Zendesk Guide or Freshdesk Solutions. It is an internal repository of Q&A pairs and scraped content that Lyro uses to generate answers to customer questions.

You manage these data sources under **Lyro AI Agent > Knowledge > Data sources** in the Tidio panel. Content enters the knowledge base through several methods:

- **URL scraping** — Tidio crawls your website pages and extracts Q&A pairs automatically
- **Manual Q&A entry** — individual question-and-answer pairs written by hand
- **File import** — CSV or PDF uploads parsed into Q&A pairs
- **HTML upload** — content submitted through the API
- **Zendesk Help Center import** — a dedicated connector for pulling in public Zendesk articles
- **Inbox extraction** — Q&A derived from solved chat conversations

In the Lyro UI, these are labeled **Manual**, **Website**, **Zendesk**, **HTML**, **Inbox**, **CSV**, and **PDF**. Tidio also documents import paths from Intercom and Gorgias for some subscribers, and supports API-based ingestion (such as during a [Kustomer to Tidio migration](https://clonepartner.com/blog/blog/kustomer-to-tidio-migration-guide/)), which means a "Tidio export" can already contain republished content from older tools. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

The underlying data model uses a **two-level hierarchy**. A **folder** is a top-level container (e.g., a scraped website or imported PDF). **QA** items are the individual question-answer pairs that live either as standalone entries or as children of a folder.

This distinction matters because the API returns different data depending on the `kind` of source. Folder items have `content: null` — you get metadata and the source URL, but not the extracted text. Only `qa` items include the actual `content` field with question-and-answer text.

When you call `GET /lyro/data-sources` without a `parent_id` filter and with `kind=qa`, the endpoint returns **all QA items across the entire project** — both those parented to folders and standalone manually created pairs. There is no top-level-only mode for QA items. To isolate standalone QAs, pull all QAs without a `parent_id` filter, then subtract the IDs returned by per-folder `parent_id` queries.

That source mix also matters because Tidio is not storing everything as clean article objects. Website scans are converted into Q&A pairs. Priority-page scans cap at 60 pages. PDFs are interpreted into Q&A while images are not imported into Q&A records. Export is possible, but it is not automatically lossless. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

## Method 1: Tidio OpenAPI — The Only Documented Programmatic Path

### Plan Requirements

The OpenAPI is the only documented way to extract knowledge base data programmatically. Here is the access matrix:

| Plan | Monthly Cost | OpenAPI Access | KB Export? |
|------|-------------|----------------|------------|
| Free | $0 | ❌ No (Products endpoint only) | No |
| Starter | $29/mo | ❌ No | No |
| Growth | $59/mo | ❌ No | No |
| Plus | From $749/mo | ✅ Yes | Yes |
| Premium | From $2,999/mo | ✅ Yes | Yes |

This is the most common blocker. If you are on a lower-tier plan and need your data out, you will need to either upgrade temporarily or use one of the alternative methods below.

### Authentication

Tidio uses custom headers — not OAuth, not Bearer tokens. Each request must include `X-Tidio-Openapi-Client-Id`, `X-Tidio-Openapi-Client-Secret`, and an `Accept` header specifying the API version. The current stable version is `version=1`. Tidio has not published a migration path for future versions; if version 2 ships, behavior of version-pinned requests is not documented. ([developers.tidio.com](https://developers.tidio.com/docs/openapi-authorization))

```bash
curl https://api.tidio.com/lyro/data-sources \
  -H "X-Tidio-Openapi-Client-Id: ci_xxx" \
  -H "X-Tidio-Openapi-Client-Secret: cs_xxx" \
  -H "Accept: application/json; version=1"
```

Generate these credentials in **Settings > Developer > OpenAPI** inside the Tidio panel. Only project owners and admins can access this section.

**Error codes you will hit:**

| HTTP Status | Cause | Action |
|-------------|-------|--------|
| `401 Unauthorized` | Wrong or missing auth headers | Verify Client ID and Secret |
| `403 Forbidden` | Plan does not include API access | Upgrade to Plus or higher |
| `406 Not Acceptable` | Missing or malformed `Accept` version header | Add `Accept: application/json; version=1` |
| `429 Too Many Requests` | Rate limit exceeded | Read `Retry-After` header and wait |

([developers.tidio.com](https://developers.tidio.com/docs/openapi-authorization))

### The `GET /lyro/data-sources` Endpoint

This endpoint does the heavy lifting. It returns a paginated list of all data sources used by Lyro.

**Base URL:** `https://api.tidio.com/lyro/data-sources`

**Query Parameters:**

| Parameter | Type | Description |
|-----------|------|-------------|
| `cursor` | string | Pagination cursor from previous response. Omit for the first page |
| `kind` | string (comma-separated) | Filter by `qa`, `folder`, or both (`qa,folder`) |
| `parent_id` | UUID | Return only direct children of a specific folder |
| `order` | string | Sort by `updated_at` — `asc` or `desc` (default: `desc`) |

**What you get back:**

For **`qa` items**, the response includes the `content` field with question-and-answer text plus full metadata. An anonymized example:

```json
{
  "data": [
    {
      "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "kind": "qa",
      "type": "manual",
      "parent_id": null,
      "content": {
        "question": "How long does shipping take?",
        "answer": "Orders ship in 3–5 business days via standard delivery."
      },
      "created_at": "2024-03-15T10:22:00Z",
      "updated_at": "2024-09-01T14:05:00Z"
    }
  ],
  "meta": {
    "cursor": "eyJpZCI6ImExYjJjM2Q0In0="
  }
}
```

For **`folder` items**, `content` is always `null`. You get `source_url`, `skip_auto_sync`, `manual_sync_available_at`, and `next_auto_sync_at` for website-type folders:

```json
{
  "data": [
    {
      "id": "f9e8d7c6-b5a4-3210-fedc-ba9876543210",
      "kind": "folder",
      "type": "website",
      "content": null,
      "source_url": "https://example.com/help/",
      "skip_auto_sync": false,
      "next_auto_sync_at": "2024-10-01T00:00:00Z",
      "created_at": "2024-01-10T08:00:00Z",
      "updated_at": "2024-09-15T12:30:00Z"
    }
  ],
  "meta": {
    "cursor": null
  }
}
```

([developers.tidio.com](https://developers.tidio.com/reference/get_lyro-data-sources))

> [!WARNING]
> **Key gotcha:** Folder items do NOT include the extracted content. If your knowledge base was built by scraping URLs, you need to fetch the child Q&A items under each folder (using `parent_id`) to get the actual content. The folder itself only tells you *where* the content came from.

### Pagination

The API uses cursor-based pagination. Each response includes a `meta` object with a `cursor` value. Pass this cursor into the next request to get the next page. When `meta.cursor` returns `null`, you have exhausted the dataset. ([developers.tidio.com](https://developers.tidio.com/docs/openapi-pagination))

For a clean export, pull `kind=folder` and `kind=qa` separately, then rebuild the hierarchy yourself. Validation is much easier than consuming the mixed stream in one pass.

```python
import requests
import time
import json

BASE = "https://api.tidio.com/lyro/data-sources"
HEADERS = {
    "X-Tidio-Openapi-Client-Id": "ci_xxx",
    "X-Tidio-Openapi-Client-Secret": "cs_xxx",
    "Accept": "application/json; version=1",
}

def fetch_all(kind):
    cursor = None
    rows = []
    while True:
        params = {"kind": kind}
        if cursor:
            params["cursor"] = cursor

        resp = requests.get(BASE, headers=HEADERS, params=params, timeout=30)
        resp.raise_for_status()

        # Store trace-id for debugging — Tidio support requires it for rate-limit investigations
        trace_id = resp.headers.get("trace-id")

        # Respect rate limits proactively
        remaining = int(resp.headers.get("x-ratelimit-remaining", 1))
        if remaining < 5:
            retry_after = int(resp.headers.get("Retry-After", 2))
            time.sleep(retry_after)

        payload = resp.json()
        rows.extend(payload.get("data", []))

        cursor = payload.get("meta", {}).get("cursor")
        if cursor is None:
            return rows

folders = fetch_all("folder")
qas = fetch_all("qa")

with open("tidio_kb_export.json", "w") as f:
    json.dump({"folders": folders, "qas": qas}, f, indent=2)
```

### Rate Limits

Tidio enforces per-project rate limits that vary by plan:

| Plan | Rate Limit | Shared Across Endpoints? |
|------|------------|--------------------------|
| Plus | 60 requests/min | Yes — all API calls share this budget |
| Premium | 120 requests/min | Yes — all API calls share this budget |

Every response includes `x-ratelimit-limit` and `x-ratelimit-remaining` headers. When you hit the limit, Tidio returns **429 Too Many Requests** with a `Retry-After` header specifying the wait time in seconds. ([developers.tidio.com](https://developers.tidio.com/docs/openapi-rate-limiting))

The rate limit applies to all API endpoints collectively — contacts, tickets, KB data, and operators all draw from the same per-minute budget. If you are running a full migration (KB + contacts + conversation history), plan your extraction sequence to avoid saturating the limit across parallel calls.

Build your extraction script to read `x-ratelimit-remaining` proactively rather than catching 429s reactively. Also store the `trace-id` header from every response — Tidio support requires it for rate-limit investigations.

At 60 req/min on Plus, a knowledge base with 2,000 Q&A pairs spread across 50 folders requires roughly 35–40 paginated requests — well within the limit for a single extraction run. A full migration including 10,000 contacts with per-contact message history at sequential 60 req/min takes several hours; plan accordingly.

## Methods for Non-API Plans

### Manual Copy from the Dashboard

If you are on a plan without API access, the dashboard is your only interface. Under **Lyro AI Agent > Knowledge > Data sources**, you can browse all Q&A pairs. The three-dot menu on each entry lets you view and edit it — but there is no bulk select, no "Select All," and no "Download as CSV."

For small knowledge bases (under ~100 Q&A pairs), manual copy-paste into a spreadsheet is tedious but workable. For anything larger, it is not a viable extraction path.

### Re-scraping Your Own Source Content

If you originally built your knowledge base by pointing Lyro at your website URLs, there is a simpler path: skip Tidio entirely and re-scrape your own content.

Tidio's URL scanner is limited to 60 pages per priority scan. Whatever content Tidio ingested, you already own it at the source. Tools like Scrapy, Cheerio, or even `wget --mirror` can pull your help center or docs site into structured files faster than navigating Tidio's API.

The trade-off: any manual edits you made to Q&A pairs *inside* Tidio after the initial scrape will be lost. If your team has done significant curation — rewriting answers, adding new pairs manually, adjusting Lyro's responses based on the Suggestions tab — those edits only exist in Tidio. The API is the only way to get them out.

> [!TIP]
> **Workaround for non-API plans:** If your knowledge base was built primarily from URL scraping, you already have the source content on your own website. Re-scrape your own URLs and you get the original content without needing Tidio's API.

> [!WARNING]
> If you rely on website-generated knowledge, do not treat Tidio as the only source of truth. Tidio's docs note that website knowledge is regenerated into Q&A pairs and re-sync can replace those pairs entirely, wiping manual edits made to URL-derived Q&A. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

### GDPR / Data Subject Access Request

Tidio is GDPR-compliant and processes personal data under EU GDPR, CCPA, and the EU–US Data Privacy Framework. Under GDPR Article 15, you have the right to request a copy of your personal data. Under Article 20, you have the right to data portability.

Contact Tidio's Data Protection Officer at **privacy@tidio.net** to request your data. Practical limits:

- GDPR requests apply to **personal data** — your Q&A content may or may not qualify depending on whether it contains personal data
- Response timelines are up to 30 days under GDPR Article 12
- The format is at Tidio's discretion (required to be a "commonly used, machine-readable format" per Article 20(1), but that could be CSV, JSON, or PDF)
- Exported Q&A content that was previously deleted from Tidio's system is not guaranteed to be included; GDPR data portability applies to data being actively processed
- This is a compliance mechanism, not a product feature — it is a last resort, not a migration tool

### Temporary Upgrade for Export

Some teams upgrade to Plus temporarily just to run an export. This works, but confirm with Tidio support before downgrading: API credentials become invalid the moment you drop below Plus tier, and Tidio's documentation does not specify whether data created or modified via API during the Plus period is affected by a subsequent downgrade.

## What Data Can and Cannot Be Exported

| Data Type | Exportable via API? | Notes |
|-----------|-------------------|-------|
| Q&A pairs (content) | ✅ Yes | `kind=qa` — includes question and answer text |
| Folder metadata | ✅ Yes | Source URL, sync settings, timestamps |
| Folder content (extracted text) | ❌ No | `content` is `null` for folders; fetch child QAs instead |
| Q&A pair status (enabled/disabled) | ✅ Yes | Available in response payload |
| Lyro conversation history | ⚠️ Partial | Thinner via API than in the admin UI |
| Lyro Suggestions (unanswered questions) | ❌ No | Not exposed via API |
| Flows (chatbot automations) | ❌ No | No API endpoint for Flow export |
| Analytics / performance metrics | ⚠️ Email only | Dashboard offers email export for analytics |
| Attachments in Q&A pairs | ⚠️ Varies | Image URLs may be included; binary files need separate download |

> [!CAUTION]
> **Not exportable:** Lyro Suggestions (the list of questions Lyro could not answer), Flow automations, and the actual extracted text from folder-level sources. If these represent significant institutional knowledge, plan to reconstruct them manually in your target system.

## Step-by-Step Export Workflow

### 1. Verify Your Plan

Confirm you are on Plus ($749/mo) or Premium. The API returns `403` on lower tiers. Check under **Settings > Developer > OpenAPI** in your Tidio panel.

### 2. Generate API Credentials

Navigate to **Settings > Developer > OpenAPI**. Copy both the Client ID and Client Secret. These are passed as `X-Tidio-Openapi-Client-Id` and `X-Tidio-Openapi-Client-Secret` headers. Only project owners and admins can access this panel.

### 3. Freeze Moving Targets

Website-based knowledge is the biggest trap. Tidio allows manual re-sync of URL sources, and on Plus or Premium it can also auto-sync them. Re-sync removes the existing website-derived Q&A pairs and replaces them with newly scanned ones — any manual edits on those records disappear. In **Lyro > Knowledge > Data sources**, turn off auto-sync for website folders before starting your export. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

Also sort your extraction by `order=asc` on `updated_at` so that if a sync occurs mid-run, you can detect modified records in the final validation pass.

### 4. Export Folders First

Call `GET /lyro/data-sources?kind=folder` to retrieve all top-level containers. Store each folder's `id`, `source_url`, and `type`. The `content` field will be `null` for all folders — this is expected behavior, not a bug.

### 5. Export Q&A Pairs Per Folder

For each folder, call `GET /lyro/data-sources?kind=qa&parent_id={folder_id}` and paginate through all children using the cursor from the `meta` object. Repeat until `meta.cursor` returns `null`.

### 6. Export Standalone Q&A Pairs

Call `GET /lyro/data-sources?kind=qa` without a `parent_id` filter. This returns **all QA items** — both folder-parented and standalone. Deduplicate against the folder children already collected (matching on `id`) to isolate manually created standalone entries.

### 7. Validate Counts

Compare your extracted record counts against what the Tidio dashboard shows under **Lyro > Knowledge > Data sources**. Spot-check content against the original pages or files. For website sources, compare exported URLs against the URLs you expected to be scanned:

- Priority-page mode covers up to **60 pages** per scan
- Total URL sources cap at **500** unless your plan permits more
- CSV imports accept **500 entries per file** and **10,000 total**

These are import-side limits that define the ceiling of what can be in your project. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

### 8. Build a Portable Schema

Do not pipe raw API payloads straight into the target platform. The API's `content` field for QA items maps to question and answer text; the `type` field identifies the source method. Create your own normalized export format:

```json
{
  "source_id": "tidio-qa-a1b2c3d4",
  "source_type": "website",
  "parent_folder_id": "f9e8d7c6-b5a4-3210-fedc-ba9876543210",
  "source_url": "https://example.com/help/shipping",
  "question": "How long does shipping take?",
  "answer": "Orders ship in 3–5 business days via standard delivery.",
  "created_at": "2024-03-15T10:22:00Z",
  "updated_at": "2024-09-01T14:05:00Z"
}
```

At minimum include: a stable export ID, source type, parent folder ID, canonical source URL, question, answer, and both timestamps. ([developers.tidio.com](https://developers.tidio.com/reference/get_lyro-data-sources))

### 9. Handle Encoding Issues

Q&A pairs created from scraped pages frequently contain HTML entities (`&amp;`, `&nbsp;`), broken Unicode, or stripped formatting. The API returns raw content without normalization. Run a pass to unescape HTML entities, normalize Unicode to NFC, and strip any residual HTML tags before importing into a target system.

### 10. Recover Canonical Sources

If a record came from a website folder, the public page is usually the better canonical source for article layout, links, and media. If it came from CSV or PDF, go back to the original file when fidelity matters.

The safe rule: **use Tidio as the extracted knowledge layer, not the archival layer.** Keep original websites, PDFs, CSVs, and any external help-center source in parallel until the new platform is live and validated.

> [!CAUTION]
> Do not delete or re-sync website sources before validation. Tidio documents that re-sync replaces website-derived Q&A and removes manual edits on those records. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

### 11. Map into the Destination Help Center

This is where Tidio exports stop being a pure extraction problem. Most destination KBs want articles, sections or folders, visibility rules, and richer metadata than Lyro needs. Tidio gives you a normalized AI-knowledge layer. You still have to decide which Q&A should become standalone articles, which should merge into longer pages, and which should stay as bot-only snippets.

## Edge Cases and Failure Modes

### Scraped Content Drift

If Tidio's auto-sync is enabled on a website folder, the Q&A pairs under that folder can change between when you start and finish your export. Disable auto-sync before extracting, or sort by `order=asc` on `updated_at` and validate that no items were modified mid-run by comparing timestamps in your final record set.

### Encoding Issues in Q&A Content

Q&A pairs created from scraped pages sometimes contain HTML entities, broken Unicode, or stripped formatting. The API returns raw content — normalize encoding before importing into a target system.

### Rate Limit Sharing Across Endpoints

The 60 req/min (Plus) or 120 req/min (Premium) limit is shared across **all** API endpoints in the project. Contacts, tickets, KB data, operators, and departments all draw from the same budget. If you are extracting KB data and conversation data in parallel, you are splitting this budget across both workloads. Sequence your extractions serially rather than in parallel to avoid 429s.

### No Sandbox Environment

Tidio does not provide a sandbox or staging environment for API testing. Every request hits production. Test your extraction scripts with minimal cursor calls (single page, small dataset) before running full exports.

### Import-Side Scope Limits

A priority website scan tops out at 60 pages. URL sources cannot point directly to files like PDFs or images. CSV imports accept 500 entries per file and 10,000 total. Those are import-side limits, but they tell you what may actually be sitting inside the project you are exporting. If a team thought it loaded "the full knowledge base" through a narrow priority scan or a stack of CSVs, your export can only be as complete as that ingestion was. ([help.tidio.com](https://help.tidio.com/hc/en-us/articles/14543666652316-Data-sources-Lyro-s-knowledge-base))

## How Tidio KB Export Compares to Other Platforms

| Platform | Native KB Export? | API Access Plan | Rate Limit | Bulk Export? |
|----------|-------------------|-----------------|------------|-------------|
| **Tidio** | ❌ No UI export | Plus ($749/mo+) | 60–120 req/min | API only |
| **Zendesk Guide** | ✅ Yes (JSON) | All plans with API | 400 req/min | Yes |
| **Freshdesk** | ✅ Yes (articles API) | All paid plans | Varies by plan | Yes |
| **Intercom** | ⚠️ Partial | All plans | 1,000 req/min | API only |
| **Help Scout** | ✅ Yes (Docs API) | All paid plans | 400 req/min | Yes |

Tidio's knowledge base portability lags behind most competitors on three dimensions: plan gating (most competitors offer API access on all paid plans), missing UI export (Zendesk, Freshdesk, and Help Scout all provide native export, though platforms like [tawk.to](https://clonepartner.com/blog/blog/how-to-export-data-from-tawkto-knowledge-base-methods-limits-gaps/) and [Desk365](https://clonepartner.com/blog/blog/how-to-export-desk365-knowledge-base-data-api-limits-methods/) share this limitation), and content gaps on folder-type sources (competitors expose full article content, not just metadata).

The migration shape that follows from these differences: with Zendesk, Freshdesk, or Help Scout you copy article objects. With Tidio you extract Q&A pairs, rebuild structure, and enrich from original sources. That is a materially more complex process, even when the API works correctly.

For destination-specific API references:

- **Zendesk:** Help Center API lists articles by category or section and supports incremental exports by update timestamp. ([developer.zendesk.com](https://developer.zendesk.com/api-reference/help_center/help-center-api/articles/))
- **Intercom:** Help Center API supports CRUD across Articles and Collections. ([developers.intercom.com](https://developers.intercom.com/docs/guides/help-center))
- **Help Scout:** Docs API is HTTPS/JSON-based with API-key auth and article create/search endpoints. ([developer.helpscout.com](https://developer.helpscout.com/docs-api/))
- **Freshdesk:** Solutions API exposes categories, folders, and article endpoints. ([developers.freshdesk.com](https://developers.freshdesk.com/api/))

## Exporting Adjacent Data: Contacts, Conversations, and Tickets

A knowledge base export is often part of a broader migration. If you are moving off Tidio entirely, you will also need contacts, conversations, and tickets. The same API — and the same plan gating — applies:

| Endpoint | Description |
|----------|-------------|
| `GET /contacts` | Paginated list of all contacts with custom properties |
| `GET /contacts/{contactId}/messages` | Full conversation history per contact |
| `GET /tickets` | Paginated list of help desk tickets |
| `GET /tickets/{ticketId}` | Individual ticket details |
| `GET /operators` | List of chat operators |
| `GET /departments` | Department structure |
| `GET /tickets/tags` | All ticket tags |
| `GET /tickets/custom-fields` | Custom field definitions |

All of these share the same per-minute rate limit as the knowledge base endpoints. For large datasets — 10,000 contacts with per-contact message history at 60 req/min — sequential extraction takes several hours. The extraction sequence matters: pull tickets and contacts before per-contact message history, because the contact IDs from `GET /contacts` are required as input to `GET /contacts/{contactId}/messages`.

For deeper dives on full platform migration, see our guides on migrating [from Tidio to Zendesk](https://clonepartner.com/blog/blog/tidio-to-zendesk-migration-guide/), [Tidio to Freshdesk](https://clonepartner.com/blog/blog/tidio-to-freshdesk-migration-guide/), or [Tidio to Groove](https://clonepartner.com/blog/blog/tidio-to-groove-migration-a-technical-guide/).

## What to Do Next

If your Tidio project is mostly manual Q&A, the export is straightforward: pull the data, validate counts, load into the target. If it mixes scanned websites, PDF-derived answers, imported Zendesk content, and years of agent edits, treat it like an ETL project with validation gates. That is the difference between "we moved some answers" and "we preserved a usable knowledge base."

The knowledge base piece is typically the *cleanest* part of a Tidio migration. It is the conversation and ticket data that gets complicated — per-contact message fetching, shared rate limits, and relational integrity across datasets.

If your situation hits any of these criteria, a self-serve export gets painful:

- **You are on a sub-Plus plan** and cannot justify $749/mo for temporary API access
- **Your KB has 500+ Q&A pairs** with extensive manual curation inside Tidio
- **You are exporting KB alongside contacts, conversations, and tickets** and need relational integrity across all datasets
- **Your target platform requires specific formatting** (e.g., Zendesk's three-tier article hierarchy, Freshdesk's folder structure)
- **You need the export done without downtime** while your team continues using Tidio

For migration planning, read [The Ultimate Knowledge Base Migration Checklist](https://clonepartner.com/blog/blog/the-ultimate-knowledge-base-migration-checklist-a-zero-downtime-plan/) next. If Zendesk is the likely destination, [our Tidio to Zendesk guide](https://clonepartner.com/blog/blog/tidio-to-zendesk-migration-guide/) goes deeper on the downstream mapping work.

> Need your Tidio data extracted cleanly — knowledge base, conversations, tickets, contacts — without upgrading to Plus or wrestling with rate limits? Our team handles the full extraction and transformation. Book a 30-minute call and we'll scope it out.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### Can I export my Tidio knowledge base from the UI?

No. Tidio does not offer a bulk UI export for Lyro knowledge base content. The only documented programmatic export is via the GET /lyro/data-sources API endpoint, which returns JSON. API access requires the Plus plan ($749/mo) or higher.

### Which Tidio API endpoint exports knowledge base data?

Use GET /lyro/data-sources. It returns a paginated list of folders and Q&A items. Filter by kind (qa or folder) and parent_id. Follow meta.cursor until it returns null to get all records.

### What Tidio plan do I need to export data via API?

You need the Plus plan ($749/mo) or Premium plan ($2,999+/mo). Free, Starter ($29/mo), and Growth ($59/mo) plans have no access to the OpenAPI endpoints required for knowledge base, contact, or ticket exports — only a single Products endpoint is available on lower tiers.

### What data is lost when exporting from the Tidio knowledge base?

Folder-level extracted content (the content field is null for folders), Lyro Suggestions (unanswered questions), Flow automations, and detailed Lyro conversation analytics are not exportable via the API. Only individual Q&A pair content is fully available. Manual edits made inside Tidio after initial URL scraping can only be retrieved through the API.

### Will the export include original PDFs or full webpage HTML?

No. Tidio converts website and file-based knowledge into Q&A records for Lyro. PDF images are not imported into Q&A output, and the list endpoint returns folder metadata and QA text rather than raw HTML or original files. Go back to your original sources when full fidelity matters.