---
title: "How to Export Data from Freshservice: API Limits, Methods & Portability"
slug: how-to-export-data-from-freshservice-api-limits-methods-portability
date: 2026-09-21
author: Raajshekhar Rajan
categories: [Freshservice]
excerpt: "Learn every method to export data from Freshservice: UI exports, scheduled CSV, REST API v2 with exact rate limits per plan, and account-level dumps."
tldr: "Freshservice data can be exported via ticket list view (CSV), scheduled Analytics exports, REST API v2 (100–500 req/min by plan), or account XML dump — but conversations, attachments, and KB articles require the API."
canonical: https://clonepartner.com/blog/how-to-export-data-from-freshservice-api-limits-methods-portability
---

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


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

*API behavior and rate limits verified against Freshservice API v2 documentation. Last reviewed: June 2025. Plan names and limits are subject to change — verify against your current contract.*

Freshservice gives you four ways to get data out: the **ticket list view export** (CSV/Excel), **Analytics scheduled exports** (CSV delivered by email or API URL), the **REST API v2** (programmatic JSON extraction), and a one-time **account-level data dump** (XML). Which one to use depends on what you're exporting, how often you need it, and whether a human or a script is doing the work.

This guide covers each method in detail, documents the exact API rate limits and pagination constraints per plan, explains error handling behavior, and flags the edge cases that trip up most teams doing Freshservice data migrations.

## What data can you export from Freshservice?

Freshservice stores ITSM data across tickets, assets, the knowledge base, changes, problems, releases, requesters, agents, contracts, software, and custom objects. All of these are accessible through at least one export path, but no single method covers everything in one shot.

Here's what's exportable and through which channel:

| Data type | List view export | Analytics scheduled export | API v2 | Account XML export |
|---|---|---|---|---|
| Tickets (incidents + SRs) | ✅ CSV/Excel | ✅ CSV | ✅ JSON | ✅ |
| Ticket conversations/notes | ❌ | ❌ | ✅ (separate endpoint) | ✅ |
| Assets / CMDB | ❌ | ✅ | ✅ JSON | ✅ |
| Knowledge base articles | ❌ | ❌ | ✅ JSON | ✅ (XML only) |
| Changes, Problems, Releases | ❌ | ✅ (Changes only) | ✅ JSON | ✅ |
| Requesters / Agents | ❌ | ❌ | ✅ JSON | ✅ |
| Contracts / Software | ❌ | ❌ | ✅ JSON | ✅ |
| Custom Objects | ❌ | ❌ | ✅ JSON | ❌ |
| Attachments | ❌ | ❌ | ✅ (download endpoint) | ❌ |
| Workflow Automator config | ❌ | ❌ | ❌ | ❌ |
| SLA policy config | ❌ | ❌ | ✅ read-only | ❌ |
| Audit logs | ❌ | ❌ | ✅ (time-range required) | ❌ |

**Key gap:** Standard list view and Analytics exports include ticket-level fields only. They do not include conversations or internal notes. If you need [conversation history — including private notes](https://clonepartner.com/blog/blog/help-desk-data-migration-playbook) — you must call the Conversations endpoint (`/api/v2/tickets/[id]/conversations`) separately for each ticket.

## How to export tickets from the Freshservice list view

The ticket list view export is the fastest way to pull a filtered set of tickets into CSV or Excel. It's a point-and-click operation that any agent can do without API access or technical knowledge.

**Steps:**
1. Go to Tickets in the left sidebar.
2. Apply filters for the tickets you want to export (status, date range, group, requester, etc.).
3. Click the export icon and choose CSV or Excel.
4. Freshservice emails you a download link.

You choose which fields to include. There is no separate permission to enable or disable ticket exports — access is determined entirely by the agent's existing ticket visibility permissions.

**Limitations:**
- Only ticket-level fields are included. No conversations, no internal notes, no child task details.
- On the **Growth plan**, custom Analytics reports may not be available. In that case, the API is the supported way to retrieve Service Request item field data.
- Service Request item fields (the custom fields filled out on a service catalog form) do not appear in standard ticket exports. The workaround is to use Workflow Automator to copy SR item field values into standard ticket fields at submission time. Once stored on the ticket, they appear in exports and Analytics.

This method is appropriate for ad-hoc reporting by non-technical staff. It is [not suitable for data migration](https://clonepartner.com/blog/blog/csv-saas-data-migration), compliance archiving, or automated pipelines.

## How to set up Freshservice scheduled data exports

A scheduled data export is a recurring CSV export configured in Analytics. Freshservice delivers it via email or an API URL on a daily, weekly, or monthly cadence. This is the standard method for feeding BI tools like Power BI or Tableau without writing API integration code.

**To configure a scheduled export:**
1. Click Analytics in the left sidebar.
2. Navigate to Settings > Data Exports.
3. Click **Create Export** in the top right corner.
4. Select the module (e.g., Changes, Assets, Tickets).
5. Choose the scheduling interval: daily, weekly, or monthly.
6. Select the fields to include.
7. Choose delivery method: Email or API URL.

The API URL delivery option provides a stable endpoint that your BI tool polls to fetch the latest export file automatically.

**Power BI-specific requirement:** Use `https` and your default Freshservice subdomain in the API URL. Power BI will fail to authenticate if the URL uses a custom domain (cname) or `http`.

**Critical limitation — schedules cannot be edited.** Once a scheduled export is created, it cannot be modified. To change fields, frequency, or delivery method, you must delete the existing schedule and create a new one.

**Available modules for scheduled export:** Tickets, Changes, Assets, Projects, Project Tasks, Project Time Entries. Problems, Releases, Requesters, Agents, and Knowledge Base articles are not available as scheduled export modules — those require API access.

## How to export Freshservice data using the REST API

The Freshservice v2 API is a RESTful JSON-over-HTTPS interface supporting full CRUD operations across all major modules. For data extraction at scale — migration, warehousing, custom integrations — this is the only option that gives complete coverage and control.

### Authentication

Freshservice API v2 uses HTTP Basic Auth. Pass your API key as the username and any non-empty string (conventionally `X`) as the password:

```bash
curl -v -u YOUR_API_KEY:X \
  -H "Content-Type: application/json" \
  -X GET 'https://yourdomain.freshservice.com/api/v2/tickets'
```

Find your API key under **Profile Settings > API Key**. Note: In newer Freshservice accounts, the API key field is hidden by default even for account owners. An administrator must enable API key visibility in account settings before agents can see it in their profile.

Freshservice API v2 does not support OAuth 2.0 or token-based auth for standard data extraction. API key auth is the only supported method for server-to-server integrations.

### Key API endpoints for data extraction

| Endpoint | What it returns |
|---|---|
| `GET /api/v2/tickets` | All tickets (last 30 days by default) |
| `GET /api/v2/tickets/filter?query=...` | Filtered ticket lists with field-level queries |
| `GET /api/v2/tickets/[id]` | Single ticket with full field detail |
| `GET /api/v2/tickets/[id]/conversations` | All conversations for a specific ticket |
| `GET /api/v2/assets` | All assets (base attributes) |
| `GET /api/v2/assets?include=type_fields` | Assets with type-specific custom fields |
| `GET /api/v2/assets/[display_id]/relationships` | CMDB relationship map for an asset |
| `GET /api/v2/requesters` | All requesters |
| `GET /api/v2/agents` | All agents |
| `GET /api/v2/solutions/categories` | KB categories |
| `GET /api/v2/solutions/folders?category_id=[id]` | KB folders within a category |
| `GET /api/v2/solutions/articles?folder_id=[id]` | KB articles within a folder |
| `GET /api/v2/changes` | All changes |
| `GET /api/v2/problems` | All problems |
| `GET /api/v2/releases` | All releases |
| `GET /api/v2/applications` | All software records |
| `GET /api/v2/contracts` | All contracts |
| `GET /api/v2/objects/[id]/records` | Custom object records |

### Pagination rules

All list endpoints use `page` and `per_page` query parameters. Pages start at 1; the maximum `per_page` value is 100 (default is 30).

```bash
# Fetch tickets 101–200 (page 2, 100 per page)
curl -u API_KEY:X \
  'https://domain.freshservice.com/api/v2/tickets?per_page=100&page=2'
```

The `link` response header contains the URL of the next page. When the `link` header is absent, you have reached the last page. Do not rely on total count headers to determine completion — use the presence or absence of the `link` header.

**Deep pagination warning:** Avoid requesting pages above 500. The API documentation explicitly warns that these calls are performance-intensive with significantly longer response times. For large datasets, use the `updated_since` filter to partition extraction into time windows instead of paginating through all records in sequence.

### The 30-day default ticket window

The List Tickets endpoint (`/api/v2/tickets`) returns only tickets created in the last 30 days by default. To retrieve older tickets, use the `updated_since` parameter with an ISO 8601 timestamp:

```bash
curl -u API_KEY:X \
  'https://domain.freshservice.com/api/v2/tickets?updated_since=2023-01-01T00:00:00Z&per_page=100&page=1'
```

This returns any ticket with an `updated_at` timestamp after the specified date. For a full historical export, set `updated_since` to a date before your earliest ticket. Note this catches tickets *modified* after that date, not necessarily *created* after — which is what you want for migration completeness.

### Filter query limitations

The `/api/v2/tickets/filter?query=...` endpoint accepts Lucene-style query strings but has a hard limit of **512 characters** per query. Complex filters combining multiple custom fields can exceed this limit and will return a 400 error. If you hit this ceiling, split the query into multiple narrower requests.

Not all filter operators available in the Freshservice UI are supported via the API. Some advanced custom filter conditions (particularly multi-value lookups on custom fields) must be implemented as post-processing in your extraction script rather than as API-side filters.

## API error codes and what they mean

Most documentation covers the happy path. Here is what you will actually encounter:

| HTTP Status | Meaning | Action |
|---|---|---|
| `200 OK` | Success | Parse response body |
| `400 Bad Request` | Malformed request, invalid filter query, or query exceeds 512 chars | Fix query syntax; check field names match API schema |
| `401 Unauthorized` | Invalid or missing API key | Verify API key; check visibility is enabled in account settings |
| `403 Forbidden` | Authenticated but insufficient permissions | The API key belongs to an agent without access to that resource (e.g., restricted ticket group) |
| `404 Not Found` | Resource doesn't exist or was deleted | Skip and log; common with deleted tickets in conversation loops |
| `409 Conflict` | Duplicate resource on write operations | Not relevant for read-only exports |
| `429 Too Many Requests` | Rate limit exceeded | Read `Retry-After` header value (in seconds) and pause before retrying |
| `500 Internal Server Error` | Freshservice-side error | Retry with exponential backoff; if persistent, contact support |

**On 429 responses:** The `Retry-After` header specifies exactly how many seconds to wait. Implement exponential backoff with jitter for resilience — a flat sleep equal to `Retry-After` works but is suboptimal under sustained load.

**On 403 vs 404:** A 403 means the resource exists but your API key's agent account lacks permission. A 404 means it doesn't exist or was deleted. In migration scripts, treat 404 on a conversations fetch as a skip (the ticket may have been merged or deleted mid-run); treat 403 as a configuration problem requiring intervention.

## What are the Freshservice API rate limits per plan?

Freshservice v2 API rate limits are enforced **per minute** and applied **account-wide** — not per user, not per API key, not per IP address. Every request counts toward your limit, including failed requests and calls from installed Freshservice apps (Freshplugs).

| Plan | Overall limit (req/min) | List All Tickets | View Single Ticket | List All Assets |
|---|---|---|---|---|
| Starter | 100 | 40 | 50 | 40 |
| Growth | 200 | 70 | 80 | 70 |
| Pro | 400 | 120 | 140 | 120 |
| Enterprise | 500 | 140 | 160 | 140 |

The sub-limits per endpoint are independent constraints. On the Pro plan, you are capped at 120 req/min for List All Tickets regardless of whether you have remaining capacity in your 400 req/min overall budget. Both limits apply simultaneously — you exhaust whichever you hit first.

**Freshplugs note:** "Freshplugs" are Freshservice marketplace apps that run under your account. Their API calls consume your account's rate limit budget. If you have multiple apps installed, their combined traffic reduces the headroom available for your own scripts. Audit installed app activity before planning a high-throughput extraction.

### Rate limit add-on packs

For migrations or heavy integrations requiring higher throughput, Freshservice offers paid add-on packs that increase API capacity above plan defaults. These are available for **Pro and Enterprise plans only**:

- **Add-on Pack 1**: Increases overall limit to 1,000 req/min
- **Add-on Pack 2**: Increases overall limit to 2,000 req/min

Migration partners working with Freshservice directly can request temporary elevated limits up to 700 req/min with written approval from Freshservice support.

### Monitoring your rate limit usage

Every API response includes rate limit headers:

```
HTTP/1.1 200 OK
X-RateLimit-Total: 400
X-RateLimit-Remaining: 387
X-RateLimit-Used-CurrentRequest: 1
```

- `X-RateLimit-Total`: Your plan's overall limit per minute
- `X-RateLimit-Remaining`: Requests remaining in the current minute window
- `X-RateLimit-Used-CurrentRequest`: Credits consumed by this specific request

**Embedded resource credit multiplier:** Requesting additional resources via the `?include=` parameter consumes extra credits per call:
- Single-object request with one embed: **2 credits**
- List request with one embed: **3 credits**

A call to `GET /api/v2/assets?include=type_fields&per_page=100` costs 3 credits against your rate limit per request. At 120 req/min (Pro plan sub-limit for list endpoints), that equates to 40 effective asset-list calls per minute instead of 120. Factor this into your pipeline design before you start.

## How to export knowledge base articles from Freshservice

Freshservice knowledge base articles cannot be exported to CSV from the UI. Two options exist:

**Option 1 — API v2:** Retrieve articles in JSON format. The KB is hierarchical (categories → folders → articles), and you must traverse each level separately:

```python
# Export all KB articles via API v2
import requests

BASE_URL = "https://yourdomain.freshservice.com/api/v2"
AUTH = ("YOUR_API_KEY", "X")

def paginate(endpoint):
    page = 1
    while True:
        resp = requests.get(f"{BASE_URL}{endpoint}", auth=AUTH,
                           params={"per_page": 100, "page": page})
        resp.raise_for_status()
        data = resp.json()
        # Extract the list (key varies by endpoint)
        items = list(data.values())[0]
        if not items:
            break
        yield from items
        if "link" not in resp.headers:
            break
        page += 1

for category in paginate("/solutions/categories"):
    for folder in paginate(f"/solutions/folders?category_id={category['id']}"):
        for article in paginate(f"/solutions/articles?folder_id={folder['id']}"):
            # article contains: id, title, description_html, tags,
            # status (1=draft, 2=published), thumbs_up, thumbs_down,
            # created_at, updated_at, author details
            save(article)
```

Each article's `description_html` contains the full HTML body. Images within articles are referenced as URLs but are not downloaded by this call — you must fetch each image URL separately.

**Option 2 — Account-level XML export:** Navigate to Admin > Account > Other Details > Export Data. Click **Export Now**. Freshservice emails a download link containing all service desk data in XML format. This includes articles but excludes embedded media and attachments — those must be downloaded separately via their URLs.

**XML export structure (tickets):** The XML export nests data as `<helpdesk_ticket>` elements containing child elements for `<notes>` (conversations), `<ticket_activities>`, and `<helpdesk_ticket_fields>`. Date fields use ISO 8601 format. Custom field values appear as named child elements under the ticket node. Understanding this structure before choosing XML export will save significant transformation effort.

## How to export assets and CMDB data

Asset data export uses the same two paths: Analytics scheduled export for recurring flat-file delivery, or the API for full-fidelity extraction including type-specific fields and CMDB relationships.

**Base asset attributes** (serial number, asset tag, state, asset type, assigned user) are returned by default:

```bash
curl -u API_KEY:X \
  'https://domain.freshservice.com/api/v2/assets?per_page=100&page=1'
```

**Type-specific custom fields** (CPU, RAM, OS version for computer assets; IP address, port count for network assets) require the `type_fields` embed:

```bash
curl -u API_KEY:X \
  'https://domain.freshservice.com/api/v2/assets?include=type_fields&per_page=100&page=1'
```

**CMDB relationships** (dependency mapping between assets) require a separate call per asset:

```bash
curl -u API_KEY:X \
  'https://domain.freshservice.com/api/v2/assets/[display_id]/relationships'
```

**Rate limit math for asset extraction:** Each list call with `type_fields` embedded costs 3 credits. On the Pro plan with a 120/min sub-limit for list operations, that yields 40 effective asset-list calls per minute. At 100 assets per page, you can retrieve 4,000 assets per minute with full type fields included — 5,000 assets takes under 2 minutes.

## Practical rate limit math for a full Freshservice data migration

Working example: 50,000 tickets with conversations, 5,000 assets with type fields, 2,000 requesters, on the Pro plan (400 req/min overall; 120/min for list calls; 140/min for single-ticket reads).

**Ticket list extraction:**
- 50,000 tickets ÷ 100 per page = 500 list calls
- Sub-limit: 120 req/min
- Time: ~4.2 minutes

**Conversation extraction (one call per ticket, non-paginated if under 10 entries):**
- 50,000 tickets × 1 call each = 50,000 calls
- Sub-limit: 140 req/min for single-ticket reads (conversations endpoint follows this limit)
- Time: ~357 minutes (~6 hours)
- If 10% of tickets have >10 conversations (paginated), add ~5,000 additional calls: ~36 more minutes

**Assets with type fields:**
- 5,000 assets ÷ 100 per page = 50 list calls × 3 credits = 150 credits
- Sub-limit: 120/min → 40 effective calls/min
- Time: ~1.25 minutes

**Requesters:**
- 2,000 requesters ÷ 100 per page = 20 list calls
- Under 1 minute

**Total estimated extraction time (sequential, single-threaded, no retries):** ~6.5–7 hours

The conversation fetch is the [dominant bottleneck by an order of magnitude](https://clonepartner.com/blog/blog/help-desk-data-migration-timeline). Mitigation options:
1. **Parallelize with throttling:** Run 2–3 concurrent workers, each staying within per-worker rate limits, to cut conversation time proportionally.
2. **Use the `include=conversations` embed on View Ticket:** Returns the first 10 conversations in a single call, eliminating the separate fetch for most tickets. Costs 2 credits per call instead of 1.
3. **Purchase a rate limit add-on:** Pack 1 (1,000 req/min) reduces conversation extraction from ~6 hours to ~50 minutes.
4. **Scope the extraction:** If only tickets from the last 2 years are needed, reduce the dataset before starting.

## Edge cases and undocumented gotchas

From working hundreds of Freshservice migrations, here are the things that catch teams off guard:

**Conversations are per-ticket and separately paginated.** The `?include=conversations` embed on a single ticket fetch returns only the first 10 conversation entries. Tickets with more than 10 entries (which is common for long-running incidents) require paginated calls to `/api/v2/tickets/[id]/conversations`. You cannot determine upfront how many calls a given ticket will need without making the first call.

**Filter queries max out at 512 characters.** Complex filter conditions with multiple custom fields can exceed this limit, returning a 400 error with a message like `"Validation failed: Query string exceeds maximum allowed length"`. Break large queries into multiple narrower requests and merge results client-side.

**Some UI filter operators are unsupported via API.** Advanced filter operators available in the Freshservice UI — particularly multi-value "contains any of" lookups on custom dropdown fields — are not implemented in the API filter endpoint. Implement these as post-processing filters in your extraction script.

**Attachments are metadata-only via API.** The API returns attachment objects with `name`, `size`, `content_type`, and `attachment_url` fields. The actual file requires a separate authenticated GET to the `attachment_url`. These URLs are time-limited; generate and download them during your extraction run, not afterward.

**Failed requests still consume rate limit quota.** A request that returns 400, 403, or 404 still counts as one request against your rate limit. A bug in your filter syntax that causes a loop of 400 errors will exhaust your quota just as fast as successful calls. Add request logging and circuit breaker logic.

**The `updated_since` parameter uses server-side timezone.** Freshservice stores timestamps in UTC. Ensure your `updated_since` values are UTC ISO 8601 strings. Passing local time without timezone offset produces unpredictable results.

**The account XML export is all-or-nothing.** You cannot select specific modules or date ranges. It exports everything in your service desk and can take several hours to generate for large accounts. The download link expires; save it immediately.

**Merged tickets become 404s.** When you fetch conversations for a ticket that was merged into another during your extraction run, the API returns 404. Your script must handle this gracefully — log the ticket ID, skip, and continue rather than treating it as a fatal error.

## What Freshservice doesn't let you export easily

Data portability from Freshservice has real limits. There is no "export everything to JSON" button. The following are either completely non-exportable or require significant manual effort:

| Configuration type | Export status | Notes |
|---|---|---|
| Workflow Automator rules | Not exportable | No API endpoint; must be recreated manually |
| SLA policy configuration | Read-only via API | Cannot export-and-reimport; must be manually recreated |
| Email notification templates | Not exportable | No API endpoint |
| Portal branding / customizations | Not exportable | No API endpoint |
| Freddy AI training data | Not portable | No export mechanism exists |
| Audit logs | API only, time-range required | Can be extracted in segments; no bulk dump |
| Service catalog categories/items | Read-only via API | Catalog structure exportable but not importable in bulk |
| Business rules / field conditions | Not exportable | No API endpoint |

If you are migrating away from Freshservice to another ITSM platform, plan to [manually recreate automations, SLA policies, notification templates, and portal configurations](https://clonepartner.com/blog/blog/how-to-migrate-automations-macros-workflows) on the target system. Budget this as a distinct workstream — it is often more time-consuming than the data migration itself.

## When to use each export method

**Use the list view export** when an agent needs a one-off CSV of filtered tickets for a report or audit. Takes under a minute, requires no technical knowledge, works within existing permission boundaries.

**Use scheduled exports** when you need recurring flat-file delivery to Power BI, Tableau, or another BI tool on a fixed cadence. Covers tickets, changes, assets, and projects. Cannot be edited after creation — only deleted and recreated. Not available on Starter plan.

**Use the REST API** when you need complete data fidelity (conversations, attachments, CMDB relationships, knowledge base articles), are building a migration pipeline, need data from modules not covered by scheduled exports (requesters, software, contracts, custom objects), or require programmatic control over extraction timing and scope.

**Use the account XML export** for compliance backup or when you need a full point-in-time snapshot of all service desk data without writing code. Comprehensive but requires XML parsing and transformation before the data is usable. Does not include attachments or embedded media.

## Getting help with Freshservice data exports

For ad-hoc exports and BI integrations, the built-in tools work. For large-scale migrations requiring conversations, attachments, asset relationships, and knowledge base articles in a clean, mapped format — the API work is substantial: rate limit orchestration, pagination logic per endpoint, error handling across five distinct failure modes, attachment downloading, and conversation threading for 50,000+ tickets.

At ClonePartner, we've built extraction pipelines against the Freshservice API for dozens of migrations. We handle the rate limit orchestration, pagination edge cases, conversation threading, and attachment downloads so you get a clean, complete dataset ready for import into your target system.

> Need to export data from Freshservice for a migration or integration? Our team handles the entire extraction — from tickets and conversations to assets and knowledge base articles — with zero downtime.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### What are the Freshservice API rate limits per plan?

Freshservice v2 API rate limits are per-minute and account-wide: Starter gets 100 req/min, Growth 200, Pro 400, Enterprise 500. Sub-limits apply to specific operations (e.g., List Tickets: 40–140/min). Paid add-on packs for Pro/Enterprise can raise the overall limit to 1,000 or 2,000 req/min.

### Can you export ticket conversations from Freshservice?

Not via the UI or scheduled exports — those only include ticket-level fields. You must use the API endpoint /api/v2/tickets/[id]/conversations to retrieve full conversation history including notes, replies, and timestamps. The include=conversations embed on a single ticket view only returns the first 10 entries.

### How do I export knowledge base articles from Freshservice?

Two options: use the Solution Article API (/api/v2/solutions/articles) to retrieve articles as JSON, or use the account-level data export under Account > Other Details to get all service desk data (including articles) in XML format. Direct CSV export of KB articles is not available in the UI.

### Does Freshservice have a full data export or backup feature?

Yes, but it's limited. Account Admins can export all service desk data in XML format from Account > Other Details > Export Data. However, it doesn't include workflow automations, SLA configurations, portal customizations, or attachment files. For complete data portability, you'll need the REST API.

### How long does it take to export 50,000 tickets from Freshservice via API?

On a Pro plan (400 req/min), exporting 50,000 tickets with conversations takes roughly 4–5 hours due to the per-ticket conversation fetch. The list calls themselves take about 2 hours. Rate limit add-on packs or working with a migration partner who has elevated limits can cut this significantly.