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

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

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.

[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)

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:

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

[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

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)

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

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)
3. Use the Client Credentials flow for server-to-server exports:

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.

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)

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

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

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)

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)

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)

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)

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)

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:

[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)
• Encoding: API responses are UTF-8. XML responses include the encoding declaration. Watch for HTML entities (&, <, ’) 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 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.

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

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

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
• How to export data from Kustomer
• Help desk data migration playbook
• Data mapping guide for help desk migrations
• GDPR-compliant data migration blueprint