---
title: "How to Export Data from tawk.to Knowledge Base: Methods, Limits & Gaps"
slug: how-to-export-data-from-tawkto-knowledge-base-methods-limits-gaps
date: 2026-08-14
author: Raaj
categories: [Knowledge Base, Migration Guide]
excerpt: "tawk.to has no built-in KB export. This guide covers four extraction methods — REST API, web scraping, browser automation, and manual — plus API limits, edge cases, and data mapping."
tldr: "tawk.to offers no native KB export. Your options are the gated REST API, web scraping, browser automation, or manual copy — each with real trade-offs around private content, media, and metadata."
canonical: https://clonepartner.com/blog/how-to-export-data-from-tawkto-knowledge-base-methods-limits-gaps/
---
# How to Export Data from tawk.to Knowledge Base: Methods, Limits & Gaps
# How to Export Data from tawk.to Knowledge Base: Methods, Limits & Gaps
*Last verified: August 2026. API behaviors and access policies may change; confirm against current vendor documentation before starting your extraction.*
tawk.to has **no built-in knowledge base export feature**. No "Export" button in the dashboard, no CSV download, no bulk export for articles or categories. This has been one of the most requested features on the tawk.to community forum since April 2023. As of mid-2026, tawk.to's official response to repeated community requests for KB export is: "At the moment, we don't have any updates to share regarding this feature. Once it's implemented, we'll announce it on our Updates page."
If you need your knowledge base content out of tawk.to, you have four real options: the gated REST API (if you can get access), web scraping of your public help center, authenticated browser automation against the dashboard, or manual copy-paste. Each comes with significant trade-offs around scope, reliability, and engineering effort.
This guide covers all four methods, what data you can actually extract, what you will lose, and how to handle the edge cases that break migrations.
> **Disclosure:** ClonePartner offers managed migration services for knowledge base platforms. This guide is written to be useful whether you hire us or do the work yourself.
## What tawk.to's Knowledge Base Actually Stores
Before planning an extraction, understand the full data model — not just article text.
The Knowledge Base is a self-service support tool in tawk.to that lets you create and share help articles with your customers and team. It serves as an online help center where visitors can find answers to frequently asked questions, reducing repetitive inquiries and improving customer satisfaction. Each property in your tawk.to account can have its own fully customizable Knowledge Base.
The data breaks down like this:
- **Articles**: Title, body content (block-based editor, not raw HTML), slug, subtitle, status (Draft, Published, Archived), visibility (Public or Private), primary category assignment, author, meta description, social media banner, and related articles.
- **Categories**: Top-level categories are the main categories shown on the front page of your Knowledge Base. These categories can contain articles and sub-categories. Both categories and articles support manual ordering.
- **Media**: Inline images, embedded videos, GIFs, and file attachments referenced within article blocks.
- **Metadata**: Creation and modification dates, author, feedback ratings (if enabled), and view analytics.
- **Multi-language content**: The software offers a customizable knowledge base that allows teams to share internal knowledge while enabling customers to self-serve. With easy content formatting, multi-language support, and real-time insights, businesses can launch and manage it effortlessly. Adding a language duplicates the category structure but does not copy article translations — changes are not synchronized across languages, and blank locale versions can exist until manually filled. Each locale must be treated as a separate export set.
- **Widget and AI dependencies**: tawk.to can surface KB articles in the chat widget as a search card, featured article, or article list of up to five items. Published public articles can also serve as an AI Assist data source.
- **Analytics**: KB views, searches, and feedback are tracked in Reporting and can be exported as CSV — but separately from article content, and not attached to individual article records via the API.
You can keep certain articles in your Knowledge Base visible only to your team. Private articles are hidden from visitors and search engines, even if someone has the direct link. Categories follow the same principle — a category will only appear publicly if it contains at least one public article.
This public/private split directly determines which extraction methods can reach which content.
## Method 1: The REST API (Gated Access)
The REST API is the most complete extraction method — if you can get access.
### How Access Works
The REST API is available by request. To get started: Fill out the REST API Access Request Form. Once your request is approved, you'll receive a username, password, and a link to the REST API documentation.
The API documentation is private. You only see it after approval. The API consists of HTTP RPC-style methods, with endpoints in the form `https://api.tawk.to/v1/METHOD`. Authentication uses HTTP Basic Auth (API key as username) over HTTPS. Responses are JSON.
> [!WARNING]
> **API access is not guaranteed.** Multiple users on the tawk.to community forum report extended waits with no response. One user reported approaching 1.5 years and 3 separate applications for API access with still no response from tawk.to — while paying $130/month for their services. Community threads from 2023–2025 show this is a recurring pattern, not an isolated case. Do not build your migration plan around API access unless you already have it.
### KB-Specific Endpoints
You can use the REST API to create properties, retrieve filtered lists of tickets, chats, or property members, view chat statistics, manage webhooks, create and list Knowledge Base articles, and create and customize chat widgets.
Based on community developer reports, the knowledge base endpoints include:
| Endpoint | Purpose |
|---|---|
| `knowledge-base.article.list` | List all articles for a property |
| `knowledge-base.article.get` | Retrieve a single article by ID |
| `knowledge-base.article.create` | Create an article (useful for import, not export) |
The `/knowledge-base.article.get` endpoint returns an article in JSON format. It includes a `contents` array field containing sections of the article. However, some users report wanting an HTML-formatted response — the API returns structured block data rather than rendered HTML, so you need to reassemble content yourself.
### What the `contents` Array Actually Looks Like
This is the hardest part of a tawk.to API extraction and the part most migration guides skip. The API does not return an HTML string. It returns a `contents` array of typed block objects. Each block type requires a different transformation rule.
Based on field reports, the structure resembles this pattern:
```json
{
"articleId": "abc123",
"title": "How to Reset Your Password",
"slug": "how-to-reset-your-password",
"status": "published",
"visibility": "public",
"contents": [
{
"type": "paragraph",
"data": {
"text": "To reset your password, visit the login page and click Forgot Password ."
}
},
{
"type": "heading",
"data": {
"text": "Step 1: Enter Your Email",
"level": 2
}
},
{
"type": "image",
"data": {
"url": "https://tawk.link/assets/images/reset-screenshot.png",
"caption": "Password reset form"
}
},
{
"type": "list",
"data": {
"style": "ordered",
"items": ["Enter your email address", "Check your inbox", "Click the reset link"]
}
}
]
}
```
To convert this to HTML for import into Zendesk, Help Scout, or Intercom, you need a block renderer — a function that maps each `type` to an HTML template:
```python
def blocks_to_html(contents):
html_parts = []
for block in contents:
btype = block.get("type")
data = block.get("data", {})
if btype == "paragraph":
html_parts.append(f"{data.get('text', '')}
")
elif btype == "heading":
level = data.get("level", 2)
html_parts.append(f"{data.get('text', '')} ")
elif btype == "image":
url = data.get("url", "")
caption = data.get("caption", "")
html_parts.append(f'{caption} {item} " for item in data.get("items", []))
html_parts.append(f"<{tag}>{items}")
# Add handlers for: code, blockquote, table, video, divider
else:
# Log unknown block types — do not silently drop them
print(f"WARNING: Unknown block type '{btype}' — skipped")
return "\n".join(html_parts)
```
**Important:** The exact field names in the `contents` array are not publicly documented. The structure above reflects community field reports and may differ from the actual API response. Build a test harness against a small subset of articles before running a full extraction, and log every block type you encounter. Unknown block types that are silently dropped will cause content loss.
### Rate Limits
**tawk.to does not publicly document its API rate limits.** Based on publicly available information, there is no specific information about the API rate limits for the tawk.to API.
Start conservatively — one request per second — and watch for `429` responses. Implement exponential backoff. For a typical KB with under 500 articles, conservative pacing will finish extraction within minutes.
### Undocumented API Behavior
Community field reports reveal inconsistencies between the private docs and actual API behavior:
- On **November 19, 2024**, a developer reported that `knowledge-base.article.get` required `categoryId`, and that retrieving article content only worked when `siteId` was set to `primary` instead of the tenant-specific site ID. ([community.tawk.to](https://community.tawk.to/t/rest-api-articles-kb/10676))
- On **June 3, 2025**, tawk.to staff said `article.meta.categories [0].name` was no longer required for article creation, calling the docs incorrect. ([community.tawk.to](https://community.tawk.to/t/rest-api-knowledge-base-article-create/13131))
- On **June 10, 2025**, the same thread recorded a working create payload only after removing that field and using a unique slug. Another poster then reported `server_error` on article update. ([community.tawk.to](https://community.tawk.to/t/rest-api-knowledge-base-article-create/13131))
Users building migration scripts report that the API is "fickle and the documentation is not reliable." Build a test harness. Validate against a non-production property before running a large export.
### Sample API Extraction Script
```python
import requests
import time
import json
BASE_URL = "https://api.tawk.to/v1"
API_KEY = "your_api_key"
API_SECRET = "your_api_secret"
PROPERTY_ID = "your_property_id"
def list_articles():
resp = requests.get(
f"{BASE_URL}/knowledge-base.article.list",
auth=(API_KEY, API_SECRET),
params={"propertyId": PROPERTY_ID}
)
resp.raise_for_status()
return resp.json()
def get_article(article_id):
resp = requests.get(
f"{BASE_URL}/knowledge-base.article.get",
auth=(API_KEY, API_SECRET),
params={"propertyId": PROPERTY_ID, "articleId": article_id}
)
resp.raise_for_status()
return resp.json()
articles = list_articles()
full_data = []
for article in articles.get("data", []):
detail = get_article(article["id"])
full_data.append(detail)
time.sleep(1) # Conservative rate limiting
with open("tawkto_kb_export.json", "w") as f:
json.dump(full_data, f, indent=2)
```
> [!NOTE]
> The exact parameter names (`propertyId`, `articleId`) and response structure may differ from what is shown. The API documentation is private and changes without public notice. Confirm against the docs you receive upon approval, and log every response structure on first run.
### What the API Gets You (and What It Doesn't)
**Extractable via API:**
- Article titles, body content (structured JSON blocks), slugs
- Category and sub-category assignments
- Article status (Draft, Published, Archived)
- Private articles (authenticated access)
**Uncertain or missing:**
- Inline image URLs need to be downloaded and re-hosted separately
- Article view counts and feedback analytics are not exposed via KB endpoints — export these separately from Reporting
- Multi-language variants: **unclear** whether the API returns all locale versions or only the primary locale. If you have multi-language content, test this explicitly against a bilingual article before assuming completeness. If it only returns the primary locale, you will need to loop through each configured language and hit the endpoint separately with a locale parameter — confirm whether that parameter exists.
- Content is returned as a `contents` array of blocks, not rendered HTML — transformation is required
## Method 2: Web Scraping the Public Help Center
This is the most accessible extraction method and the one most teams actually use.
### Scraping Permissions: Check tawk.to's Terms First
Before implementing any scraper, review tawk.to's Terms of Service regarding automated access. At time of writing, tawk.to's public ToS does not contain an explicit prohibition on automated retrieval of your own publicly-hosted KB content, but this can change and may be interpreted differently for third-party or competitive scraping. Scraping your own public help center to migrate your own content is a materially different scenario from scraping a competitor's content — but you should confirm this interpretation against the current ToS before beginning, particularly if you are operating under a contract with specific acceptable-use clauses.
Additionally, check whether your tawk.to subdomain generates an XML sitemap. Many tawk.to KBs expose one at `https://yourname.tawk.help/sitemap.xml`. If a sitemap exists, it is the most reliable entry point for URL discovery — more complete than crawling category pages and less fragile than regex-based link extraction.
### Why Scraping Works
Your tawk.to KB is hosted at a subdomain. By default, your subdomain is "name.tawk.help". You can also use a custom domain. If your Knowledge Base is public, its content can be indexed by search engines like Google, helping more people discover your support articles. If Google can crawl it, so can your scraper.
Public articles render as standard HTML pages with predictable URL structures:
- Category pages: `https://yourname.tawk.help/category/category-slug`
- Article pages: `https://yourname.tawk.help/article/article-slug`
### How to Scrape tawk.to KB Articles
**Step 1: Discover all article URLs.** Check for a sitemap at `/sitemap.xml` first. If none exists, start from your KB's homepage and crawl each category page to collect article links. Categories may contain sub-categories, so recurse through the full tree.
**Step 2: Fetch and parse each article page.** Use a library like BeautifulSoup (Python) or Cheerio (Node.js) to extract the article title, body HTML, and category breadcrumbs.
Here is a conceptual Python script:
```python
import requests
from bs4 import BeautifulSoup
import json
import time
def discover_urls_from_sitemap(base_url):
sitemap_url = f"{base_url}/sitemap.xml"
resp = requests.get(sitemap_url)
if resp.status_code != 200:
return []
soup = BeautifulSoup(resp.text, "xml")
return [loc.get_text() for loc in soup.find_all("loc") if "/article/" in loc.get_text()]
def extract_tawkto_article(url):
response = requests.get(url)
if response.status_code != 200:
return None
soup = BeautifulSoup(response.text, 'html.parser')
# CSS selectors vary based on your tawk.to KB theme — inspect your actual pages
title_element = soup.select_one('h1.article-title')
body_element = soup.select_one('div.article-content')
breadcrumbs = [a.get_text(strip=True) for a in soup.select('nav.breadcrumb a')]
if not title_element or not body_element:
return None
return {
"source_url": url,
"title": title_element.get_text(strip=True),
"html_body": str(body_element),
"category_path": breadcrumbs
}
base_url = "https://yourname.tawk.help"
article_urls = discover_urls_from_sitemap(base_url)
results = []
for url in article_urls:
data = extract_tawkto_article(url)
if data:
results.append(data)
time.sleep(1.5) # Respect the server
with open("scraped_articles.json", "w") as f:
json.dump(results, f, indent=2)
```
**Step 3: Download media.** Find all `A community-built n8n workflow template connects directly to your tawk.to Help Center, reads all published categories and articles, converts them to Markdown (.md) format, and uploads each file to Google Drive. It automatically transforms HTML content into clean Markdown files — perfect for editing, version control, or migration to another CMS. It saves each article with a structured filename, avoids duplicates, and organizes them by category.
This template is available on n8n.io (workflow #9785). It is a solid no-code starting point, though it only handles public articles and its reliability depends on the tawk.to DOM remaining stable.
### What Scraping Gets You (and What It Doesn't)
**What you get:**
- Article titles and full HTML body content
- Category hierarchy (from breadcrumbs or URL structure)
- Inline images and embedded media URLs
- Article slugs and URLs
**What you lose:**
- Private articles are hidden from visitors and search engines, even if someone has the direct link.
- Draft and Archived articles are always hidden from visitors regardless of visibility.
- Article metadata: creation dates, modification timestamps, author, view counts, feedback ratings
- SEO fields: meta description, social banner, related articles
- Programmatic category IDs (you only get slugs and names from breadcrumbs)
> [!TIP]
> **Respect the server.** Add a 1–2 second delay between requests. Don't launch concurrent scrapers against a shared service. For a large KB (500+ articles), pace your requests across several minutes.
## Method 3: Authenticated Browser Automation
When API access is unavailable and scraping cannot reach your private or draft content, browser automation against the tawk.to dashboard is the fallback.
This means scripting Playwright or Puppeteer to log into the dashboard, open each article in the KB editor, collect fields from the document panel (title, slug, status, visibility, category, SEO metadata), and serialize the block-based content from the editing surface.
**Trade-offs:**
- **Scope:** Can reach everything — private articles, drafts, archived content, editor metadata
- **Speed:** Much slower than API or scraping; each article requires a full page load and editor initialization
- **Fragility:** UI selectors change without notice. Session expiry, MFA prompts, throttling, and lazy-loaded block content can break a run halfway through
- **Maintenance:** High for ongoing sync; acceptable for a one-off extraction
- **Block content:** The editor surface may render blocks differently than the API returns them — you are scraping a visual representation, not structured data
This method exists because tawk.to's API access is gated and unreliable. It is engineering overhead you should not need, but sometimes it is the only path to a complete export.
## Method 4: Manual Copy-Paste
For small knowledge bases (under 30 articles), manual extraction is often the fastest path with the fewest technical failure modes.
Log into the tawk.to dashboard, open the Knowledge Base editor, and copy each article's content into your target format. You get access to public and private articles, drafts, and archived content. The dashboard shows metadata (status, category, dates) that is not available through scraping.
The trade-offs are obvious: it does not scale past ~30 articles, rich text formatting may not survive copy-paste (tables, code blocks, and embedded media are the most failure-prone), and you must manually record categories, slugs, and metadata in a separate spreadsheet.
## Extraction Method Comparison
| Factor | REST API | Web Scraping | Browser Automation | Manual Copy-Paste |
|---|---|---|---|---|
| **Access** | Requires application + approval | Public articles only | Dashboard login | Dashboard login |
| **Scope** | All articles (incl. private, draft) | Published public only | All articles (incl. private, draft) | All articles |
| **Format** | Structured JSON (block data) | Raw HTML (needs parsing) | Editor DOM (needs parsing) | Unstructured (clipboard) |
| **Media** | URLs in response (download separately) | URLs in HTML (download separately) | Visible in editor | Manual download |
| **Metadata** | IDs, status, dates (if exposed) | None | Visible in editor UI | Visible in editor UI |
| **Scalability** | High (automated) | Medium (automated with caveats) | Low–Medium | Low (< 30 articles) |
| **Reliability** | Depends on access approval | Depends on DOM stability | Fragile (UI changes) | Always works |
| **ToS risk** | Approved access — minimal | Low for own content; verify ToS | Gray area; minimize footprint | None |
## Edge Cases: A Decision Matrix
These are the issues that catch teams off guard. Each entry maps a condition to its consequence and the method required to address it.
| Condition | Consequence if Ignored | Required Method | Implementation Note |
|---|---|---|---|
| **You have private articles** | Scraping misses them entirely; you discover the gap after cutover | API or browser automation | Private articles are invisible to any unauthenticated request, even with the direct URL |
| **You have draft or archived content** | Draft = not public; archived = not public. Both are scraping blind spots | API or browser automation | Confirm with dashboard article count vs. scraper output count |
| **Block-based content (API path)** | Unknown block types silently dropped = silent content loss | Log every block type during extraction | Build a renderer for all known types; alert on unknowns before importing |
| **Multi-language content** | API may only return primary locale; other locales silently omitted | Test explicitly with a bilingual article | If locales require separate API calls, loop through each configured language |
| **Multiple properties** | Each property has an isolated KB — no cross-property export | Run extraction separately per property | Count articles per property in dashboard before starting |
| **Inline images and attachments** | tawk.to CDN URLs break after account closure | Download and re-host all assets before importing | See Asset Trap section below |
| **Internal links between articles** | Links point to old tawk.to URLs after migration | Build an old→new URL map; run a second-pass rewrite | Do not publish migrated articles until rewrite is complete |
| **SEO-indexed articles** | Old URLs return 404 after migration; rankings drop | Configure 301 redirects from old URLs to new | Map every old URL before DNS cutover |
| **Analytics data** | KB views, searches, and feedback are not in article API responses | Export Reporting CSVs before cutover | Analytics live in a separate export path — do not assume they come with the article |
| **No article versioning** | You only get the current state; no revision history available | Accept this limitation; export immediately before any content freeze | Inform stakeholders that historical revisions are not recoverable |
## The Asset Trap: Migrating Images and Attachments
Extracting article HTML is only half the job. The most common cause of data loss in a KB migration is **orphaned assets**.
When you extract an article from tawk.to, the HTML contains image tags pointing to tawk.to's infrastructure:
`` tag pointing to a tawk.to domain (`tawk.link`, `tawk.to`, or your custom domain).
2. **Download the file.** Make a GET request to each tawk.to CDN URL and save the image locally or to an S3 bucket.
3. **Upload to the target platform.** Use your new platform's API (e.g., Zendesk's Create Article Attachment endpoint, Help Scout's Docs API) to upload the file.
4. **Rewrite the HTML.** Replace the old tawk.to URL in the `src` attribute with the new URL from your target platform.
5. **Import the updated article.** Only publish the article after HTML rewriting is complete.
> [!WARNING]
> **Do not skip asset rewriting.** Relying on hotlinked images from a vendor account you are about to close is a guaranteed way to silently destroy your help center's usability days or weeks after the migration appears "finished." The breakage is invisible until a user reports a missing image — by which time the account may be gone.
## Handling Internal Links and SEO
Knowledge base articles are highly interconnected. Article A links to Article B. When you migrate, destination URLs change, and every internal link breaks if you do not handle it.
### Resolving Internal Links
Maintain an identity map during migration:
1. Create a mapping of `old_tawkto_url → new_platform_url` for every article.
2. After all articles are imported and their new URLs are generated, run a second pass over your entire new knowledge base.
3. Find every old tawk.to URL in the article bodies and replace it with the corresponding new URL.
### Preserving SEO with 301 Redirects
If your tawk.to KB is indexed by Google, breaking those URLs destroys your search rankings and sends customers to 404 pages.
Export a complete list of your tawk.to article URLs and map them to the new URLs in your destination system. Most modern help desks (Zendesk Guide, Help Scout) allow you to configure 301 redirects or customize URL slugs. If the KB runs on a custom domain, plan the DNS cutover as part of your redirect strategy — tawk.to's custom domain setup uses a CNAME pointing to `your-property-id.tawk.help`.
## Exporting Other tawk.to Data Types
If you are migrating off tawk.to entirely, you need more than just KB articles.
### Chat History
Admins can export chat transcripts. Hover over a chat and tick the checkbox that appears. To select multiple chats, tick additional checkboxes, or click the checkbox at the top of the list to select all visible chats. The recipient will receive an email with a link to download a ZIP file containing the chats in JSON format.
You can only select "all visible chats" on the current page. At this moment, the only way is manual export, and there is a limit of conversations as well. For large chat histories, paginate through the inbox and export in batches.
### Tickets
An email will be sent with a link to download the exported tickets. The link is valid for 30 days. Only Admins can export tickets. Exports are JSON. Rich text formatting (bold, italics, links) will be stripped in the CSV export.
### Contacts
You will receive an email with a link allowing you to download a .csv with all current contact information for the property. Contact export is straightforward — it is the one data type tawk.to handles well.
### Knowledge Base
No built-in export. That is why you are reading this guide.
## Data Mapping: tawk.to to Target Platforms
tawk.to uses a flat two-tier hierarchy: **Categories → Sub-categories → Articles**. When migrating, you must map this to your target platform's model.
| tawk.to Field | Zendesk Guide | Freshdesk KB | Intercom Articles | Help Scout Docs |
|---|---|---|---|---|
| Article title | `title` | `title` | `title` | `name` |
| Article body | `body` (HTML) | `description` (HTML) | `body` (HTML) | `text` (HTML) |
| Category | Section → Category | Folder → Category | Collection | Collection → Category |
| Sub-category | Section (nested) | Sub-folder | Section | Category (nested) |
| Visibility | User segments | Visibility settings | Audience targeting | Visibility |
| Status | `draft` / `published` | `draft_status` | `state` | `status` |
| Meta description | `meta_description` | Not native | Not native | Not native |
| Article slug | `html_url` (partial) | `permalink` | Not directly settable | `slug` |
**Zendesk-specific structural requirement:** Zendesk Guide enforces a three-tier hierarchy — **Categories → Sections → Articles**. If your tawk.to KB uses only two tiers (Category → Article, no sub-categories), you must create intermediate Sections in Zendesk even when there is no functional sub-category. Plan for this before import — it affects how you organize and name your target structure. (See our [Zendesk Guide export guide](https://clonepartner.com/blog/blog/how-to-export-data-from-zendesk-guide-methods-limits-formats/) for structural details.)
A normalized export record that works as an intermediate format for any of these targets:
```json
{
"sourcePropertyId": "...",
"articleId": "...",
"locale": "en",
"title": "...",
"slug": "...",
"status": "published",
"visibility": "public",
"author": "...",
"categoryIds": ["..."],
"primaryCategoryId": "...",
"metaDescription": "...",
"relatedArticleIds": ["..."],
"contentBlocks": [],
"renderedHtml": "",
"assetMap": {
"https://tawk.link/original-image.png": "https://your-new-host.com/migrated-image.png"
},
"sourceUpdatedAt": "..."
}
```
The `assetMap` field is the key addition: keeping the old-to-new URL mapping inside each article record means your HTML rewrite pass has everything it needs in one place, rather than maintaining a separate global asset registry.
For platform-specific guidance, see our migration guides:
- [tawk.to to Zendesk Migration](https://clonepartner.com/blog/blog/tawkto-to-zendesk-migration-a-technical-guide/)
- [tawk.to to Freshchat Migration](https://clonepartner.com/blog/blog/tawkto-to-freshchat-migration-a-technical-guide/)
- [tawk.to to Helpshift Migration](https://clonepartner.com/blog/blog/tawkto-to-helpshift-migration-a-technical-guide/)
## Pre-Migration Checklist
Before starting extraction:
1. **Inventory the surface area.** Count properties, languages, categories, and articles. Note the public/private split per property. Check whether a sitemap exists at `/sitemap.xml`. Count articles visible in the dashboard vs. articles discoverable via public scraping — the gap is your private/draft exposure.
2. **Audit unpublished content.** Web scraping only captures public articles. Identify drafts, archived articles, and private content that need API access, browser automation, or manual extraction. Decide before starting whether that content is required.
3. **Review tawk.to's ToS.** Confirm automated access to your own public KB is permitted under your current agreement.
4. **Choose the extraction path.** Use the API if you have approval. Use scraping for public content. Use browser automation when private or draft content matters and the API is unavailable. Do not depend on API approval — start scraping in parallel.
5. **Export analytics separately.** Pull KB Reporting CSVs for views, searches, and feedback before cutover. These are not available through the KB API endpoints.
6. **Freeze content updates.** Instruct your team not to create or edit tawk.to articles while extraction and import are running.
7. **Build your asset pipeline before importing articles.** Download all CDN-referenced media and generate new hosting URLs before running the import. Do not import articles with unresolved tawk.to image URLs.
8. **Build your old→new URL map before publishing.** Run the internal link rewrite pass after all articles are imported but before any are published. Publishing before rewriting means readers see broken internal links.
9. **Plan the reader-facing cutover.** Map DNS changes, rebuild widget references, and set up 301 redirects before flipping traffic.
10. **Validate counts and relationships.** Compare total article count per language and property. Check category membership, slug collisions, image integrity, and internal link validity. Spot checks are not sufficient — compare every migrated article against the source.
For a broader planning framework, our [Knowledge Base Migration Checklist](https://clonepartner.com/blog/blog/the-ultimate-knowledge-base-migration-checklist-a-zero-downtime-plan/) covers the full process from audit to validation.
## Getting Your tawk.to KB Data Out
tawk.to delivers real value as a free live chat platform with an integrated help center. The absence of any built-in knowledge base export creates genuine friction when it is time to migrate, back up content, or syndicate articles to another system.
Your realistic options in order of technical complexity: REST API (complete access, gated approval), web scraping (public content, no approval required), browser automation (private and draft content, high implementation effort), and manual extraction (small volumes only).
For most teams, web scraping is the practical starting point. It requires no approval, captures the content that most readers use, and gets you something testable within hours. Layer in browser automation or manual extraction only if your private article count justifies the additional effort.
Whatever method you choose, the article body is the easy part. Plan explicitly for: block-to-HTML conversion (including unknown block type handling), image re-hosting before import, internal link rewriting before publishing, 301 redirects before DNS cutover, and a validation pass comparing source article counts against migrated output per language and property. Those five steps are where tawk.to migrations break, regardless of which extraction method you use.
> Stuck on a tawk.to knowledge base extraction? ClonePartner handles the API access headaches, block content transformation, media re-hosting, and validation. Book a 30-minute scoping call with our engineers.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)
## Frequently asked questions
### Can you export knowledge base articles from tawk.to?
No. tawk.to has no built-in knowledge base export — no CSV download, no bulk export button, no one-click option. You need to use the gated REST API (requires application and approval), scrape your public help center pages, use authenticated browser automation against the dashboard, or manually copy content from the editor.
### How do I get access to the tawk.to REST API?
Fill out the REST API Access Request Form on tawk.to's help center. If approved, you receive credentials and a link to private documentation. Approval is not guaranteed — some users report waiting over a year with no response despite multiple applications.
### Does tawk.to publicly document API rate limits?
No. tawk.to does not publish its REST API rate limits. The API documentation is only available to approved users. Start conservatively at one request per second and implement exponential backoff on 429 responses.
### What happens to article images when I leave tawk.to?
Images in tawk.to articles are hosted on their CDN. If you migrate article HTML without downloading and re-hosting the images, they will break as soon as your tawk.to account is closed. You must programmatically download every asset and rewrite image URLs during migration.
### Can I scrape private or draft tawk.to KB articles?
No. Public scraping only reaches rendered public pages. Private articles are team-only, and Draft and Archived articles are always hidden from visitors. For private or unpublished content, you need REST API access, authenticated browser automation, or manual extraction from the dashboard.
`
If you import this raw HTML into your new platform, the images render correctly — until you close your tawk.to account. tawk.to does not publicly document how long CDN assets remain accessible after account closure or property deletion. Assume they go down immediately. Do not rely on hotlinked images from a deprecated vendor account.
### How to Fix the Asset Dependency
For every article, your migration process must:
1. **Parse the HTML.** Run a DOM parser to find every `