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.

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:

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:

{
  "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 <b>Forgot Password</b>."
      }
    },
    {
      "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:

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"<p>{data.get('text', '')}</p>")
        elif btype == "heading":
            level = data.get("level", 2)
            html_parts.append(f"<h{level}>{data.get('text', '')}</h{level}>")
        elif btype == "image":
            url = data.get("url", "")
            caption = data.get("caption", "")
            html_parts.append(f'<figure><img src="{url}" alt="{caption}"><figcaption>{caption}</figcaption></figure>')
        elif btype == "list":
            tag = "ol" if data.get("style") == "ordered" else "ul"
            items = "".join(f"<li>{item}</li>" for item in data.get("items", []))
            html_parts.append(f"<{tag}>{items}</{tag}>")
        # 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)
• 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)
• 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)

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

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)

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:

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 <img> and other media tags in the article body. Download the files and update references to point to your new hosting. (Details in the asset migration section below.)

Step 4: Convert to your target format. Transform extracted HTML to Markdown, JSON, or whatever your destination platform expects.

Handling Rate Limits and Blocking

Even public scraping can trigger rate limits or Cloudflare blocks:

• Implement a 1–2 second delay between requests
• Use standard browser-like User-Agent headers
• Run sequentially rather than concurrently — parallel scrapers against a shared hosting environment will get your IP temporarily blocked

Community Workaround: n8n Workflow

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)

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

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.

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:

<img src="https://tawk.link/assets/images/your-image-id.png">

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 <img> and <a> 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.

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.

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 for structural details.)

A normalized export record that works as an intermediate format for any of these targets:

{
  "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
• tawk.to to Freshchat Migration
• tawk.to to Helpshift Migration

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 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.