---
title: "How to Export Data from eGain: API Limits, Methods & Portability"
slug: how-to-export-data-from-egain-api-limits-methods-portability
date: 2026-07-31
author: Abdul
categories: [eGain]
excerpt: "Export eGain data via REST API, Analytics reports, or Knowledge Console. No bulk export exists — API caps at 75 records/page. Full guide to methods, limits, and gaps."
tldr: "eGain has no \"Export All\" button. The REST API (v3) is the primary method for cases and customers, capped at 75 records per page. Knowledge exports use Print Preview, legacy APIs, or RTKA. Workflow configs cannot be exported at all."
canonical: https://clonepartner.com/blog/how-to-export-data-from-egain-api-limits-methods-portability/
---

# How to Export Data from eGain: API Limits, Methods & Portability


# How to Export Data from eGain: API Limits, Methods & Portability

> [!NOTE]
> **TLDR:** eGain has no "Export All" button. The REST API (v3 for cases and customers, legacy APIs for knowledge content) is the primary extraction method, capped at **75 records per page**. Knowledge articles can also export via Print Preview or the Real-Time Knowledge Access bulk export to S3/SFTP. Analytics reports export aggregate metrics, not individual records. Workflow configurations, routing rules, and integration settings cannot be exported at all. Engineering resources are required for any complete export.
>
> **Last verified:** July 2025, against eGain SaaS (cloud-hosted) platform. API paths and behaviors reference eGain v22.x+ documentation. On-premise deployments may differ in API availability, authentication, and rate behavior.

eGain is a **knowledge management and digital customer engagement platform**, not a pure helpdesk. Its data model spans two domains: knowledge content (articles, topics, folders, guided help) and customer interactions (cases, activities, customers, conversations). What many teams call "ticket export" is really export of **Cases** plus their child **Activities**, related **Customers**, **Notes**, and **Attachments** — each requiring separate API calls.

This guide covers every extraction path: what each method actually returns, what it drops, the exact pagination and authentication constraints, and the operational failures that catch teams mid-migration.

## What Data Can You Export from eGain?

Before planning an extraction, you must map eGain's data model. The exportability of each object depends on the method you use.

| Object | Analytics Report Export | Knowledge Console Export | REST API Export | Format | Known Limitations |
|---|---|---|---|---|---|
| **Cases** | Yes (aggregate metrics) | No | Yes (`/core/casemgr/v3/case`) | JSON, XML | API search supports exact match only. Must use `$attribute=all` for full case data. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-casemgr/api-bundled/overview/)) |
| **Activities** | Yes (aggregate metrics) | No | Yes (`/core/casemgr/v3/activity`) | JSON, XML | Must be fetched per-case or via search. Chat transcripts and email bodies require `$attribute=all`. |
| **Customers** | No | No | Yes (`/core/customermgr/v3/customer`) | JSON, XML | `Get Customer by IDs` allows up to 75 comma-separated IDs per request and does not support pagination. Bulk export depends on the search operation. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-customermgr/api-bundled/operation/customerByIDs/)) |
| **Conversations** | No | No | Yes (Conversation Manager API) | JSON, XML | Message content may require separate per-conversation fetching. |
| **Notes** | No | No | Yes (`/core/casemgr/v3/note`) | JSON, XML | Must be fetched per-case. No bulk search export path. |
| **Articles** | No (aggregate stats only) | Yes (Print Preview → PDF/Excel) | Yes (Portal Manager or Authoring APIs) | JSON, XML, PDF, Excel | Print Preview captures rendered content. API returns HTML body. Inline images may need separate download. |
| **Topics & Folders** | No | Partial (Print Preview) | Yes (`/knowledge/portalmgr/v4/portals/{portalID}/topics`) | JSON, XML | Hierarchical structure requires `$level=-1` to expand full tree. ([apidev.egain.com](https://apidev.egain.com/api-catalog/knowledge-portalmgr/api-bundled/v4/operation/getalltopics/)) |
| **Guided Help / Case Bases** | No | Yes (XML export) | Partial | XML | Exports entire case base as a single XML file. No individual article export from case bases. |
| **Attachments** | No | No | Yes (Case Manager for activities; Authoring API for articles) | Binary + metadata | Must download individually via `contentUrl`. Some attachment types are deleted from server after first download. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-casemgr/api-bundled/operation/getActivityAttachmentDetails/)) |
| **Users / Agents** | No | No | Yes (User Manager API) | JSON, XML | Permission-dependent. Cannot export password hashes. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-usermgr/api-bundled/operation/userByLoginID/)) |
| **Departments** | No | No | Yes (Department Manager API) | JSON, XML | Straightforward extraction. |
| **Analytics / Reports** | Yes | No | No | Excel, PDF, CSV, XML, HTML, Tiff | Aggregate metrics only — not individual record-level data. ([help.egain.com](https://help.egain.com/help/standard%20dashboards%20and%20reports/about_reports.htm)) |
| **Workflows, routing, integrations** | No | No | No documented bulk export | N/A | Admin-managed objects, not part of a supported portability package. ([help.egain.com](https://help.egain.com/help/administration/user_role_administrator.htm)) |

[For engineering] **Critical behavior to know:** eGain API responses return only a pre-defined set of summary attributes by default. If you do not include `$attribute=all` in your GET requests, you will receive truncated records missing fields like activity content, customer contact points, and case custom attributes. This is the single most common export mistake with eGain — it silently drops data from your response without warning. No error is returned; you simply receive fewer fields.

Two additional constraints to catch early: if customer departmentalization is enabled, user-scoped exports can be restricted by department. And if you rely on Analytics for custom field exports, eGain only records custom attributes you explicitly enabled for Analytics, with a limit of **10 custom attributes per object type**. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-customermgr/api-bundled/operation/customerByIDs/))

## SaaS vs. On-Premise Deployment Differences

eGain is available as both a cloud-hosted SaaS platform and an on-premise deployment. Export behavior differs between the two:

| Factor | SaaS (Cloud-Hosted) | On-Premise |
|---|---|---|
| **API availability** | All documented REST APIs available via public endpoints | APIs may require VPN/internal network access; firewall rules must allow outbound data transfer |
| **Authentication** | OAuth 2.0 client credentials via eGain-hosted token endpoint | Token endpoint hosted internally; may use different IdP integration |
| **Rate limits** | Server-side throttling managed by eGain; no tenant-configurable overrides | Throttling depends on local infrastructure capacity; can often sustain higher throughput |
| **Data residency** | Region-specific hosting (US, EU, APAC); export may trigger cross-border data transfer obligations | Data resides on customer infrastructure; no transfer concerns during export |
| **RTKA availability** | Licensed feature on qualifying SaaS plans | May require separate configuration for S3/SFTP connectivity |
| **Direct database access** | Not available | Possible with DBA access; bypasses API pagination entirely but voids support agreements |

For on-premise deployments with direct database access, teams sometimes bypass the API entirely and query the underlying Oracle or SQL Server database. This is faster but unsupported — eGain's schema is not documented for direct access, and schema changes between versions can break queries without notice.

## Export Methods: Every Way to Get Data Out of eGain

| Method | Data Coverage | Volume Limit | Speed | Complexity | Best For |
|---|---|---|---|---|---|
| **Analytics Report Export** | Aggregate reporting data only | Report-dependent | Fast (minutes) | Low | PMs needing operational metrics |
| **Knowledge Console Print Preview** | Articles (content + metadata) | All articles in selected folder | Moderate | Low | One-time article snapshots |
| **Case Base XML Export** | Guided help content | Entire case base | Moderate | Low | Backing up decision-tree content |
| **REST API (v3 Core)** | Cases, Activities, Customers, Conversations, Users, Departments | 75 records/page | Slow at scale | High | Full data migration or integration |
| **Legacy REST API (v11/v12/v15)** | Articles, Topics, Folders, Attachments (knowledge-focused) | 75 records/page | Slow at scale | High | Knowledge base extraction |
| **Real-Time Knowledge Access (RTKA)** | KB metadata, HTML content, attachments, portal/language bundles | Async export; up to 250 articles per JSON file | High for KB | Medium | Full knowledge backup or migration ([apidev.egain.com](https://apidev.egain.com/developer-portal/guides/export/real-time-knowledge-access)) |

[For PMs] **Zero-engineering options:** Analytics report exports and Knowledge Console Print Preview require no developer resources. Everything else requires at least one engineer who can write API integration code.

**Webhook/event stream note:** eGain does not expose a general-purpose webhook or event-stream mechanism for near-real-time data replication. There is no equivalent of Zendesk's incremental export API or Salesforce's Change Data Capture. All export is pull-based via REST API polling. If you need ongoing data synchronization rather than a one-time export, you must build a scheduled polling job against the search endpoints.

## Native UI Export: Step-by-Step

eGain's admin UI does not have a traditional "Export to CSV" button for cases, customers, or activities. The native export options break down into three workflows.

### Exporting Analytics Reports

1. Navigate to **eGain Analytics**
2. Open or create the desired report (real-time or historical)
3. Click the export button and choose your format: **Excel, PDF, CSV, XML, HTML**, or **Tiff**
4. Optionally, schedule recurring report delivery via email in your chosen format

> [!WARNING]
> Analytics exports contain **aggregate operational data** — metrics like case volumes, resolution times, agent performance, and queue statistics. They do **not** export individual case records, customer records, or conversation transcripts. Do not confuse report exports with data exports.

### Exporting Knowledge Articles via Print Preview

1. Log in to the **eGain Knowledge Console**
2. Navigate to the knowledge base folder containing your articles
3. Click **Print Preview** in the Tree Pane toolbar
4. The preview renders all articles in the selected folder with content, name, and folder path
5. Export the preview as **PDF** or **Excel**

This method produces a human-readable snapshot of article content. It captures rendered formatting but does not preserve article metadata like creation dates, version history, or language variants. Attachments are not included.

### Exporting Guided Help Case Bases

Case bases (decision-tree content used in guided help) can be exported as a single **XML file** from the Knowledge Console. This copies the entire case base, including all embedded articles. There is no option to export individual articles from a case base — it is all or nothing.

### Admin Utility Exports

A handful of narrow admin objects have dedicated UI export paths: `Security > User Accounts > Password Blacklist > Export File` downloads a CSV, and `Security > Data Masking > Patterns > Export Pattern` downloads XML. These are useful examples of how limited the native export surface is. ([help.egain.com](https://help.egain.com/help/administration/password_blacklist_about.htm))

## API-Based Export: Endpoints, Pagination, and Rate Limits

The REST API is the only method that provides structured, record-level access to eGain's full data model. eGain maintains two API families, and you may need both depending on what you are extracting.

### API Families

| API Family | Version | Auth Method | Default Format | Primary Use |
|---|---|---|---|---|
| **Core/Modern APIs** | v3 | OAuth 2.0 (Client Credentials) | JSON or XML | Cases, Activities, Customers, Conversations, Users, Departments |
| **Legacy Authoring/Access APIs** | v11, v12, v15 | Session-based (`X-egain-session` header) | XML | Articles, Topics, Folders, Attachments, Portals |

### Authentication Setup

**For v3 APIs (recommended for case and customer data):**

1. Register a Client Application in the eGain Administration Console to generate your **Client ID** and **Client Secret**
2. Access the application's **Metadata** to find your Authorization and Token URLs — use these rather than hard-coding a public hostname, as the API domain may differ by tenant ([developer-qe.ezdev.net](https://developer-qe.ezdev.net/developer-portal/get-started/authentication_guide))
3. Use the **Client Credentials flow** for server-to-server exports:

```bash
curl --location --request POST '<YOUR_TOKEN_URL>' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data-urlencode 'grant_type=client_credentials' \
  --data-urlencode 'client_id=<CLIENT_ID>' \
  --data-urlencode 'client_secret=<CLIENT_SECRET>' \
  --data-urlencode 'scope=<REQUIRED_SCOPES>'
```

4. Include the returned token as `Authorization: Bearer <access_token>` in all subsequent requests. OAuth tokens have a finite TTL (typically 3600 seconds); refresh before expiry.

**For legacy APIs (knowledge content):**

1. Call the **Login API** to create a session
2. Store the `X-egain-session` header from the response
3. Include this header in all subsequent requests
4. Sessions time out after approximately **20 minutes** of inactivity — handle re-authentication in your export scripts
5. Always call the **Logout API** when done to release the license; otherwise the license is held until session timeout

### Pagination

eGain offers two mutually exclusive pagination approaches. **You cannot combine them in the same request** — doing so returns a `400 Bad Request`.

| Parameter | Type | Default | Max | Notes |
|---|---|---|---|---|
| `$pagenum` | Page-based | 1 | — | Used with `$pagesize` |
| `$pagesize` | Page-based | 25 | **75** | Maximum records per page |
| `$rangestart` | Range-based | 1 | — | Used with `$rangesize` |
| `$rangesize` | Range-based | 25 | **75** | Maximum records per range request |

The **maximum page size of 75 records** is a hard limit. For a dataset of 100,000 cases, you need a minimum of 1,334 API calls just for the case list — before fetching activities, notes, or attachments for each case.

For the `Get Customer by IDs` endpoint specifically, the operation accepts up to 75 comma-separated IDs per request and explicitly does not support pagination or range parameters. Bulk customer export depends on the search operation instead. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-customermgr/api-bundled/operation/customerByIDs/))

### Rate Limits

eGain does not publish a single suite-wide requests-per-minute quota in its public documentation. The Access (self-service) APIs documentation states that API usage is monitored as session usage, where **a session is 10 minutes in duration and a maximum of 10 calls is permitted**, with overages billed per eGain's pricing terms.

The v3 Core APIs do not publish explicit per-minute or per-day rate limits in their public docs. In practice, sustained high-volume extraction may trigger server-side throttling or session termination. Build exponential backoff into your scripts regardless — when throttled, the server returns `HTTP 429 Too Many Requests`. Read the `Retry-After` header and pause execution. If you fail to implement backoff, eGain may temporarily block your session or IP.

### Common API Error Codes During Export

| HTTP Status | Meaning | Typical Cause During Export | Recommended Action |
|---|---|---|---|
| `400 Bad Request` | Malformed request | Mixing `$pagenum` with `$rangestart`; missing required query parameter; requesting attachments on non-email/non-chat activity types | Validate request parameters against endpoint docs |
| `401 Unauthorized` | Auth token expired or invalid | OAuth token TTL exceeded; legacy session timed out after 20 min inactivity | Re-authenticate and retry |
| `403 Forbidden` | Insufficient permissions | Client app scope does not cover the requested resource; department restrictions | Verify OAuth scopes and user role assignments |
| `404 Not Found` | Resource does not exist | Referencing a deleted case, customer, or attachment; using wrong API version path | Log the ID and continue; add to orphan report |
| `429 Too Many Requests` | Rate limit exceeded | Sustained high-frequency polling without delays | Read `Retry-After` header; implement exponential backoff starting at 5 seconds |
| `500 Internal Server Error` | Server-side failure | Large response payload; transient infrastructure issue | Retry with exponential backoff (max 3 attempts); if persistent, reduce `$pagesize` |
| `503 Service Unavailable` | Server overloaded or in maintenance | Maintenance window; excessive concurrent sessions | Pause export; retry after 60 seconds; check eGain status page |

### Key API Endpoints for Export

```
# Cases
GET /core/casemgr/v3/case?$attribute=all&$pagenum=1&$pagesize=75

# Activities (interactions within cases)
GET /core/casemgr/v3/activity?caseID={id}&$attribute=all&$pagenum=1&$pagesize=75

# Customers
GET /core/customermgr/v3/customer?$attribute=all&$pagenum=1&$pagesize=75

# Articles (legacy Authoring API)
GET /system/ws/v12/kb/article?$attribute=all&$lang=en-us&$pagenum=1&$pagesize=75

# Articles (Portal Manager API)
GET /knowledge/portalmgr/v3/portals/{portalID}/articles?filter[topic]={topicID}&$pagenum=1&$pagesize=75&$attribute=all

# Article attachments
GET /system/ws/v12/kb/attachment?article={articleId}&$lang=en-us&$attribute=all

# Activity attachments
GET /core/casemgr/v3/activity/{ids}/attachment/{attachmentID}?$attribute=contentUrl

# Folder hierarchy (full tree)
GET /system/ws/v12/kb/folder?$level=-1

# Topic tree (v4)
GET /knowledge/portalmgr/v4/portals/{portalID}/topics
```

### Paginated Case Export with Retry Logic

```python
import requests
import time

def export_all_cases(base_url, token, page_size=75):
    page = 1
    all_cases = []
    
    while True:
        url = f"{base_url}/core/casemgr/v3/case"
        params = {
            "$attribute": "all",
            "$pagenum": page,
            "$pagesize": page_size
        }
        headers = {
            "Authorization": f"Bearer {token}",
            "Accept": "application/json"
        }
        
        for attempt in range(3):
            resp = requests.get(url, params=params, headers=headers)
            
            if resp.status_code == 200:
                data = resp.json()
                cases = data.get("cases", {}).get("case", [])
                if not cases:
                    return all_cases
                all_cases.extend(cases)
                page += 1
                break
            elif resp.status_code == 401:
                token = refresh_token()  # Re-authenticate
            elif resp.status_code == 429:
                retry_after = int(resp.headers.get("Retry-After", 2 ** attempt * 5))
                time.sleep(retry_after)
            elif resp.status_code >= 500:
                time.sleep(2 ** attempt * 5)
            else:
                raise Exception(f"API error {resp.status_code}: {resp.text}")
        else:
            raise Exception(f"Max retries exceeded on page {page}")
    
    return all_cases
```

### Real-Time Knowledge Access (RTKA) for Bulk Knowledge Export

For large knowledge bases, eGain offers **Real-Time Knowledge Access** — an asynchronous bulk export that writes to a customer-provided **Amazon S3 bucket or SFTP server**. Each exported JSON file can contain up to 250 articles, and the file tree includes JSON metadata, HTML article bodies, and attachment files. ([apidev.egain.com](https://apidev.egain.com/developer-portal/guides/export/real-time-knowledge-access))

This is a licensed feature, not available on all plans. But for teams with 10,000+ knowledge articles, RTKA is significantly faster than paginating through the Portal Manager API at 75 records per page. For a 10,000-article knowledge base, RTKA produces roughly 40 JSON part files plus HTML and binary folders, compared to a minimum of 134 paginated API calls just for the article list (plus separate calls for each article's attachments).

### Throughput Math

At 75 records per page with conservative pacing (1 request per second to avoid triggering undocumented throttling):

- **75 records/second** for a single object type (list calls only)
- **~270,000 records/hour** theoretical maximum for list calls

In practice, you will be far slower because each case requires separate calls to fetch its activities, notes, and attachments. A realistic sustained throughput for a full case export is **500–2,000 fully hydrated case records per hour**, based on the following assumptions:

- **Average of 4 activities per case** (each requiring a separate GET call with `$attribute=all`)
- **30% of activities have at least one attachment** (each requiring a content URL fetch + binary download)
- **~200ms average network latency per API round-trip** to eGain's cloud endpoints
- **1-second intentional delay between requests** to stay below undocumented throttling thresholds
- The lower end (500/hr) applies to cases with 8+ activities and multiple attachments; the upper end (2,000/hr) applies to cases averaging 2 activities with no attachments

This means a 100,000-case dataset with typical activity density takes **50–200 hours of extraction time** — or 2–8 days of continuous operation. Plan for interruptions: network failures, token expiry, and transient 500 errors will add 15–25% to the raw extraction time.

## Does eGain Let You Export Attachments?

Yes, but attachments are a separate extraction problem. They are never included inline in case or article export responses.

**For activity attachments:** Use the Case Manager API at `/core/casemgr/v3/activity/{ids}/attachment/{attachmentID}`. Request `$attribute=contentUrl` to get a download URL. The endpoint returns `400` if the activity type is not email or chat — calltrack and other activity types are excluded. ([apidev.egain.com](https://apidev.egain.com/api-catalog/core-casemgr/api-bundled/operation/getActivityAttachmentDetails/))

**For knowledge article attachments:** Use the legacy Authoring API at `/system/ws/v12/kb/attachment?article={articleId}&$lang=en-us` or the v4 Portal Manager endpoints at `/knowledge/portalmgr/v4/articles/attachments/{attachmentID}`. The RTKA bulk export writes attachments into per-article folders alongside the exported HTML content. ([apidev.egain.com](https://apidev.egain.com/apis/v4/knowledge/portalmgr/api-bundled/article/getattachmentbyidinportal))

> [!CAUTION]
> **One-time download trap:** eGain's documentation for suggestion attachments states that the `contentUrl` "only exists temporarily on the server" and "the attachment can be retrieved only once as it is deleted from the server after download." If this behavior applies to your attachment type, you cannot retry a failed download without re-requesting the URL. Build download verification (check HTTP 200 response, validate file size > 0 bytes, compute SHA-256 checksum) and write to local storage immediately before processing.

**File size limits:** Chat attachments are configurable from 2 MB to 10 MB per file, and knowledge-base attachments are configurable from 1 MB to 25 MB, with a default of 3 MB. Incoming email size, including content and attachments, is capped by the partition setting for maximum email size. ([help.egain.com](https://help.egain.com/help/administration/allowing_attachment_file_types.htm))

**Inline images** embedded within email or article HTML bodies are typically referenced by URL. If those URLs point to eGain-hosted assets, you must separately download and re-host them — they will break if you decommission the eGain instance. eGain may also store inline email images as base64-encoded strings within the HTML payload or as CID (Content-ID) references. If your destination platform does not support CID parsing, these images will appear as broken links after migration. To handle this: parse the HTML for `cid:` references, match them to MIME parts or attachment IDs in the activity response, download each, re-host on your target platform's CDN, and rewrite the `src` attributes in the HTML body.

**Retention risk:** eGain purge jobs can remove chat transcripts, email attachments, audit data, and case/activity details on a schedule. If retention windows are active, a late export request becomes a data-retention problem, not just an API problem. Check your purge configuration before planning any export timeline. ([help.egain.com](https://help.egain.com/help/administration/storage_about_purge_jobs.htm))

## What Data Cannot Be Exported from eGain?

Every platform has export blind spots. Here is what you cannot get out of eGain through any documented method:

| Data Type | Exportable? | Why It Matters | Workaround |
|---|---|---|---|
| **Workflow/automation configurations** | No | Represent months of operational logic encoding business rules, escalation paths, and conditional routing | Manual audit using Admin Console screenshots; document each workflow step-by-step before decommissioning |
| **Routing rules and assignment logic** | No | Control which agents receive which case types; encode team structure and skill-based routing | Export agent skill assignments via User Manager API; manually document routing rules from Admin Console |
| **Custom views and saved filters** | No | Represent agent-specific or team-specific workflow optimizations | Screenshot and recreate; interview power users for undocumented filters |
| **User permissions and role definitions** | Partial — user records exportable via User Manager API, but role *definitions* (what each role can do) are not bulk-exportable | Role definitions encode your security model | Export user-to-role mappings via API; manually document role permission matrices from Admin Console |
| **Analytics dashboards and report definitions** | No — aggregate report *data* exportable, but the dashboard configurations and report definitions are not | Custom reports represent analytics investment | Export all report data in all formats before decommissioning; recreate definitions in target |
| **Integration configurations** | No | API keys, webhook URLs, middleware mappings | Document all active integrations, credentials (stored in your secrets manager, not eGain), and data flow diagrams |
| **SLA/escalation policy definitions** | No | Encode response time commitments and escalation chains | Document from Admin Console; map to target platform's SLA framework |
| **Deleted/archived records** | No documented API access | May be needed for compliance or legal holds | Contact eGain support; may require professional services engagement |
| **Audit logs** | No bulk export API | Required for compliance and security forensics; audit data has its own purge category | Contact eGain support for manual extraction; note that purge jobs may have already removed older entries ([help.egain.com](https://help.egain.com/help/administration/storage_about_purge_jobs.htm)) |
| **Password hashes / auth credentials** | No | Expected — no platform exports credential material | Users must re-authenticate in target; plan for password reset communications |

[For customer success] The critical gap for most teams is **workflow and routing configurations**. These represent significant operational logic that must be manually documented and rebuilt in any target platform. In our experience, workflow recreation typically consumes 30–40% of total migration project time for organizations with complex routing trees — more than the data extraction itself. Teams consistently underestimate this.

## Data Format, Encoding, and Cleanup After Export

eGain's APIs support **XML** (default on legacy APIs) and **JSON** (supported on all v3 APIs, optional on legacy). Article content bodies are stored as **HTML** inside the API response regardless of the response format.

### Common Data Quality Issues in eGain Exports

- **HTML in text fields:** Article bodies and activity content contain raw HTML. If you are migrating to a platform that uses Markdown or plain text, you must run an HTML-stripping and conversion script (e.g., using Python's `html2text` or `BeautifulSoup`), or your new system will display unreadable code blocks.
- **Date format inconsistencies:** The v3 knowledge article responses use date strings like `29 Jun 2022 03:45:18.000 +0000`, while v4 topic responses use ISO-style timestamps such as `2022-05-23T19:44:02Z`. The v3 Case Manager API uses yet another format. Normalize all timestamps to ISO 8601 UTC during the landing phase, not during import. ([apidev.egain.com](https://apidev.egain.com/api-catalog/knowledge-portalmgr/api-bundled/v3/operation/getArticlesInTopic/))
- **Encoding:** API responses are UTF-8. XML responses include the encoding declaration. Watch for HTML entities (`&amp;`, `&lt;`, `&#x2019;`) in article content that may need decoding.
- **Orphaned references:** Activities referencing deleted customers, or articles referencing removed folders, will have dangling IDs in export data. Build an orphan report during extraction — log every foreign key that fails to resolve.
- **Summary vs. full attributes:** If you forget `$attribute=all`, you will get records missing key fields. This bears repeating — it is the most common eGain export mistake. A case exported without `$attribute=all` may return only `caseId`, `subject`, `status`, and `createdDate`, omitting custom attributes, assigned agent, department, and priority.

### Post-Export Validation Checklist

1. ✅ Verify record counts match between eGain UI and exported data (compare against Analytics report totals)
2. ✅ Confirm all cases have their associated activities exported (check that activity count per case matches the `activityCount` field on the case record)
3. ✅ Check that article bodies contain full HTML content, not just summaries (verify character count > 100 for articles known to have content)
4. ✅ Validate that customer contact points (email, phone) are present — missing contact points indicate `$attribute=all` was omitted
5. ✅ Verify attachment files were downloaded and are not corrupted (check file sizes > 0 bytes; validate checksums if available)
6. ✅ Confirm date/time values are in expected timezone and format
7. ✅ Spot-check 10 records across different object types for field completeness: 3 recent, 3 oldest, 2 with most activities, 2 with largest attachments
8. ✅ Verify hierarchical relationships (folder trees, case-activity links) are intact — reconstruct the tree and diff against the UI
9. ✅ Run a foreign key integrity check: every `customerId` on a case should resolve to an exported customer record

## Export for Migration vs. Backup vs. Compliance

Your extraction strategy changes based on your end goal.

**Migration:** You need **structured, relationship-preserving data** — every case linked to its activities, every article linked to its folder and attachments. ID mapping is critical: eGain's internal IDs will not match destination platform IDs, so you must build a mapping table during import. The target platform's import constraints (field length limits, supported HTML tags, attachment size caps) will dictate post-export transformation requirements. You can often leave behind data older than three years to reduce scope — verify this with your legal and compliance teams first.

**Backup:** Full-fidelity snapshots require extracting every object with `$attribute=all` and downloading all attachments. Schedule recurring API-based exports if eGain does not offer built-in backup. Store exports in an immutable, versioned format — dated JSON files in cloud storage with a manifest tracking record counts, extraction timestamps, and checksums.

**Compliance (GDPR, DSAR):** For **GDPR Article 20 data portability**, you must provide personal data in a "structured, commonly used, and machine-readable format." Here is the technical workflow for DSAR fulfillment using eGain's API:

1. **Search by identifier:** Query `GET /core/customermgr/v3/customer?$attribute=all` with the data subject's email address as a search filter
2. **Retrieve associated cases:** For each matching customer ID, query `GET /core/casemgr/v3/case?customerId={id}&$attribute=all` to pull all cases
3. **Retrieve activities per case:** For each case, query activities with `$attribute=all` to capture full conversation history
4. **Download attachments:** Fetch all attachments associated with the data subject's activities
5. **Compile output:** Merge into a single JSON document or structured ZIP archive containing customer profile, all cases, all activities, and all attachments
6. **Right-to-erasure verification:** If the request includes deletion (Article 17), confirm all extracted records are complete *before* executing deletion via the Customer Manager API's delete operation — there is no undo

eGain maintains a [Data Processing Addendum](https://hd.egain.com/contracts/uk_data_processing_addendum.pdf) covering international data transfers under Standard Contractual Clauses — relevant if you are exporting data from an EU-hosted eGain instance.

## Contract Termination and Data Access

eGain's standard subscription agreements do not publicly guarantee a specific data export window or format at contract termination. Based on typical enterprise SaaS practices:

- **Data retention post-termination** is typically 30–90 days, after which eGain may delete tenant data. Verify the exact window in your Master Subscription Agreement.
- **There is no documented self-service "Download All My Data" mechanism** triggered by contract termination. You must complete your API-based export before the contract ends or before your API credentials are revoked.
- **Request a data dump from eGain support** as a fallback. Enterprise contracts may include provisions for eGain to provide a database export, but this is not standard and must be negotiated.

**Bottom line:** Do not assume you can export after termination. Begin your data extraction at least 60 days before contract end, and confirm your API credentials will remain active through the export window.

## Vendor Lock-In and Data Portability Assessment

[For CTOs]

**eGain data portability rating: Partially Locked.**

| Factor | Assessment |
|---|---|
| **Knowledge content (articles, topics, folders)** | Exportable via API with full HTML bodies. Attachments require separate extraction. Guided help case bases export only as monolithic XML with no individual article granularity. RTKA improves bulk KB export for licensed users. |
| **Case/interaction data** | Exportable via v3 API but only 75 records per page, exact-match search only, no bulk export job or incremental export mechanism. |
| **Customer records** | Exportable via API. No bulk export function — search operation required for scale. |
| **Workflow and routing logic** | Not exportable. Must be manually documented and recreated. |
| **Analytics and reporting definitions** | Not exportable. Only aggregate report data can be downloaded. |
| **Integrations** | Not exportable. Must be rebuilt. |

**What percentage of data can you get out cleanly?** Approximately 70–80% of your *data* (cases, customers, articles, attachments) is extractable through the API. Nearly 100% of your *operational configuration* — workflows, routing rules, SLA policies, dashboards, integration configs — cannot be exported at all. This configuration debt is where the real switching cost hides.

### Data Portability Comparison: eGain vs. Zendesk vs. Intercom vs. Salesforce Service Cloud

| Capability | eGain | Zendesk | Intercom | Salesforce Service Cloud |
|---|---|---|---|---|
| **Bulk record export** | No bulk job; paginated API only (75/page) | Incremental Export API (1,000/page); full JSON bulk export via Support admin | Cloud storage export to S3/GCS (full account data) | Data Export service (weekly CSV); Data Loader (bulk API, 10,000/batch); also SOQL query export |
| **Max page/batch size** | 75 records | 1,000 records (incremental); 100 per page (list) | N/A (full export) | 2,000 records (REST); 10,000 (Bulk API 2.0) |
| **Incremental/delta export** | Not supported — must re-export everything or track state externally | Native: `start_time` parameter returns only records modified since timestamp | Not natively supported for ongoing sync | Change Data Capture (CDC) for real-time event streaming |
| **Attachment export** | Separate API calls per attachment; some one-time-download restrictions | Included in ticket export as URLs; bulk downloadable | Included in export package | Attachment object queryable via API; binary download via content URL |
| **Webhook/event stream** | None | Webhooks for ticket, user, and organization events | Webhooks for conversations, contacts, and events | Platform Events, Change Data Capture, Outbound Messages |
| **Workflow/config export** | Not exportable | Partial — triggers, automations, macros exportable via API | Not exportable | Full metadata API; change sets; Salesforce DX for version-controlled config |
| **Self-service "Download All"** | No | Yes (Admin Center > Account > Data export) | Yes (Settings > Data Management > Export) | Yes (Setup > Data Export) |
| **GDPR/DSAR tooling** | Manual API workflow required | Built-in GDPR deletion/export tool in Admin Center | Data deletion/export via Settings | Built-in Individual Rights features in Privacy Center |
| **Rate limits** | Undocumented for v3; legacy APIs: 10 calls/10-min session | 400–700 requests/minute (depends on plan) | Varies by endpoint; typically 1,000/min for most APIs | 100,000 API calls/24hr (Enterprise); Bulk API: 15,000 batches/24hr |
| **Engineering effort for full export** | High — custom scripts required for every object type | Low to Medium — bulk export covers most data with minimal code | Low — single export request covers account data | Medium — Data Loader handles most cases; complex orgs need Bulk API scripts |

The comparison makes eGain's portability gaps concrete: no incremental export, no self-service bulk download, no webhook infrastructure, and the lowest page size cap of any platform in this comparison. The engineering effort required for an equivalent full-data export from eGain is 3–5x higher than from Zendesk or Intercom.

## Timeline and Resourcing for a Full Data Export

| Phase | Small (<10K records) | Medium (10K–100K records) | Large (100K+ records) |
|---|---|---|---|
| **Scoping & API access provisioning** | 1–2 days | 2–3 days | 3–5 days |
| **Script development & testing** | 2–3 days | 3–5 days | 5–10 days |
| **Extraction** | 2–4 hours | 4–24 hours | 1–5 days |
| **Attachment downloads** | 1–4 hours | 4–12 hours | 1–3 days |
| **Validation & cleanup** | 1 day | 2–3 days | 3–5 days |
| **Total elapsed time** | 4–6 days | 7–12 days | 12–25 days |

**Minimum team composition:**
- **Analytics export only:** 0 engineers (self-serve through UI)
- **API export:** 1 backend engineer with REST API experience
- **Full migration (export + transform + import):** 1–2 engineers + 1 PM

The extraction phase itself is not the bottleneck. Script development and post-export validation consume the majority of project time. Activities must be fetched per-case and attachments per-record — the number of API calls scales multiplicatively, not linearly. For a 50,000-case dataset averaging 4 activities per case, you need approximately 50,000 (cases) + 200,000 (activities) + 60,000 (attachment fetches at 30% rate) = **310,000 API calls minimum**, taking roughly 86 hours at 1 request/second.

---

## Related Resources

If you are benchmarking portability across support platforms, these guides cover the export process for other systems:

- [How to export data from Zendesk](https://clonepartner.com/blog/blog/how-to-export-data-from-zendesk-guide-methods-limits-formats/)
- [How to export data from Kustomer](https://clonepartner.com/blog/blog/how-to-export-data-from-kustomer-methods-api-limits-data-portability/)
- [Help desk data migration playbook](https://clonepartner.com/blog/blog/help-desk-data-migration-playbook/)
- [Data mapping guide for help desk migrations](https://clonepartner.com/blog/blog/your-ultimate-guide-to-data-mapping-for-a-flawless-help-desk-data-migration-with-csv-templates/)
- [GDPR-compliant data migration blueprint](https://clonepartner.com/blog/blog/gdpr-compliant-data-migration-the-enterprise-blueprint/)

---

> Planning an eGain data export or migration? ClonePartner's engineers handle the API extraction, data transformation, and relationship mapping — so your team stays focused on the business cutover, not debugging pagination scripts.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### Can I export all my data from eGain?

You can export most record-level data — cases, activities, customers, articles, conversations, and attachments — through eGain's REST API. There is no single "Export All" button. Workflow configurations, routing rules, analytics dashboards, and integration settings cannot be exported and must be manually recreated in any target system.

### Does eGain export include attachments?

Not automatically. Attachments must be downloaded separately via the API using the contentUrl attribute returned with attachment metadata. Article attachments use the Authoring API; activity attachments use the Case Manager API. There is no bulk attachment download endpoint, and some attachment URLs are temporary and deleted after first download.

### How long does it take to export data from eGain?

For a small dataset under 10,000 records, expect 4–6 business days including script development and validation. For 100,000+ records, plan for 12–25 business days. The API's 75-record page limit means extraction for large datasets can take multiple days of sustained calls, and activities must be fetched per-case.

### Is there a way to export eGain data without using the API?

Yes, but with major limitations. eGain Analytics reports export to CSV, Excel, PDF, XML, or HTML — but only aggregate metrics, not individual records. The Knowledge Console Print Preview exports articles to PDF or Excel. Guided help case bases export to XML. For record-level case, customer, or activity data, the API is the only path.

### Can I export eGain data for GDPR compliance?

Yes, but you must build the workflow. eGain's API can produce JSON exports of individual customer records that satisfy GDPR Article 20 requirements for structured, machine-readable format. There is no built-in self-service data portability tool — your team must query the Customer Manager API to fulfill data subject access requests.