Migration planning

ServiceNow Export to Excel Stops at 10,000 Rows: Get Everything

ServiceNow data export stops at 10,000 rows and leaves work notes, audit history and attachments behind. See what each route misses and how to get it all.

Ayush BothraFounding Member, MigrateX

Published 14 min read

ServiceNow data export limits: list exports stop at 10,000 records by default, and attachments are stored in 4 KB chunks
On this page

A ServiceNow data export stops at 10,000 rows because list exports fall back to the glide.ui.export.limit system property, which defaults to 10,000 records. Raising it only fixes the row count. Work notes and comments live in sys_journal_field, field history in sys_audit and files in sys_attachment and sys_attachment_doc, so a list export leaves them all behind. To get every ticket out with its full conversation, history and files, read those tables through the Table API and Attachment API, page by page, inside your instance's rate limits.

This guide is for ServiceNow platform owners and IT leaders who are leaving, archiving or moving to another tool, and for system integrators scoping an exit. It covers what each export route misses, which table holds what, the paging math, and a checklist to run before you start. For the full migration plan, see our ServiceNow migration guide.

Why does ServiceNow export stop at 10,000 rows?

ServiceNow caps list exports to protect instance performance. Each format has its own property (glide.csv.export.limit, glide.xlsx.export.limit, glide.xml.export.limit, glide.json.export.limit), and when that property is not set, the export falls back to glide.ui.export.limit, which defaults to 10,000 records, per ServiceNow's export limits documentation.

Three more limits catch people out:

LimitWhat it doesSource
glide.ui.export.limitFallback row cap for every list export format, default 10,000ServiceNow docs, Export limits
Excel cell capExcel exports are limited to fewer than 500,000 cells, so a wide table stops well before 10,000 rowsServiceNow docs, Export limits
Visible fields onlyA list export includes only the columns in the current view, unless the URL adds sysparm_default_export_fields=allServiceNow docs, Export directly from a URL
glide.ui.export.warn.thresholdAbove this count, the user chooses between waiting and getting the export by emailServiceNow docs, Export limits

An admin can raise the limits under System Properties > Import Export, and ServiceNow warns that limits above the defaults may affect system performance. Even at a higher cap, a list export to Excel or CSV is a flat table of the fields you chose. It is a report, not a copy of your records.

What does each ServiceNow export route miss?

Every built-in route misses something. List exports to CSV or Excel miss conversations, history and files. XML carries record IDs but not reliably the journal. Export Sets copy one table at a time. The Table API can reach everything but costs calls. The MySQL dump at contract end has everything in raw form, and very little you can open.

Here is the matrix we use when scoping an exit. "Yes" means the route carries that data for a full table without custom work.

Export routeWork notes and commentsAudit historyAttachmentsDisplay valuesRecord IDs (sys_id)
List export (CSV, Excel)No as separate entries; at best, flattened text if you add a journal columnNoNoYes, what the list showsOnly with sysparm_default_export_fields=all
XML exportInconsistent: Community users report sys_journal_field is sometimes included, sometimes notNoNoNo, stored values; references come out as sys_idsYes
Export Sets (to a MID Server)Only if you build a separate export definition on sys_journal_fieldOnly with a separate definition on sys_auditNo files, only rowsDepends on the format and fieldsYes, if you include the field
Table APIYes, by querying sys_journal_fieldYes, by querying sys_auditMetadata from sys_attachment; files through the Attachment APIYes, with sysparm_display_value=all (both values)Yes
MySQL dump at contract endYes, raw rowsYes, raw rowsYes, as chunks in sys_attachment_doc that you must reassembleNo, references are sys_ids you must resolveYes

Two rows need more context.

XML is the format admins use to move a handful of records between instances. It carries stored values, so it is useful for a rebuild, but each export is still subject to the same row limit (glide.xml.export.limit, falling back to glide.ui.export.limit), and history lives elsewhere.

Export Sets pair an export definition (a table or view, its fields and a filter) with a file format and a destination on a MID Server. They can run on a schedule, export only changed records based on sys_created_on or sys_updated_on, and split a large job into parallel files. They solve volume, not shape: each definition still exports one table, and the files land on the MID Server, so you still need a step to move them.

Where do work notes, history and attachments live in ServiceNow?

A ticket in ServiceNow is spread across several tables. The incident row holds the current field values. Work notes and comments are separate rows in sys_journal_field. Every field change is a row in sys_audit. Files are a metadata row in sys_attachment plus data chunks in sys_attachment_doc. A complete export reads all of them and joins them back by sys_id.

TableWhat it holdsHow it links to the ticket
task and its children (incident, sc_req_item, change_request, problem, sc_task)The current value of every field on the recordsys_id is the record's permanent ID; number is the human ID
sys_journal_fieldOne row per work note, additional comment or other journal entry, with author and timeelement_id = parent sys_id, name = parent table, element = work_notes or comments
sys_auditOne row per field change: old value, new value, who and whendocumentkey = parent sys_id, tablename, fieldname
sys_history_set, sys_history_lineThe History view the UI showsBuilt on demand from audit and journal data, so they are not a complete record (Fivetran's ServiceNow docs)
sys_attachmentFile metadata: name, content type, size, parent table and recordtable_name + table_sys_id = the parent ticket
sys_attachment_docFile data, in 4 KB chunkssys_attachment = the file's sys_id; position = chunk order
sys_user, sys_user_groupPeople and groups referenced by tickets, including departed agentsReference fields store their sys_ids
sys_choiceThe labels behind choice fields such as state, priority and categoryname + element + value
task_slaSLA records attached to each tasktask = parent sys_id
sys_emailInbound and outbound email logged against recordsinstance = parent sys_id

Two details trip up most homegrown exports.

  • History tables are not the history. sys_history_line rows exist only for records whose history someone has viewed. Export sys_audit and sys_journal_field instead, then rebuild the timeline from them.
  • Insert history can be missing. If the glide.sys.audit_inserts property was false, there is no audit row for the moment a record was created. Use sys_created_on and sys_created_by on the record itself.

How are ServiceNow attachments stored?

ServiceNow's attachment documentation says each file creates a metadata record in sys_attachment, and the file data is stored in sys_attachment_doc in 4 KB chunks. To export attachments, either call the Attachment API, which returns the whole binary file by the attachment's sys_id, or read the chunks in position order and reassemble them.

The Attachment API is the simpler route: GET /api/now/attachment/{sys_id}/file returns the file. Use the sys_id of the sys_attachment row, not the ticket's sys_id, and take the file name and content type from the metadata row, because the binary response alone does not carry them. Admins on the ServiceNow Community describe the chunks as gzipped and then base64-encoded, so rebuilding from sys_attachment_doc means decoding and unzipping each file.

Plan for size. The com.glide.attachment.max_size property sets the largest file an instance accepts, in megabytes; ServiceNow's attachment limit documentation gives 1024 (1 GB) as the recommended maximum. A single ticket can hold a file that large, and the target system may accept far less.

How do you export all records with the ServiceNow Table API?

The ServiceNow Table API returns up to sysparm_limit records per call, which defaults to 10,000. To export a full table, repeat the call and add the limit to sysparm_offset each time until a call returns no records. Ask for sysparm_display_value=all to get both the stored value and the display value of every field.

A minimal call for incidents:

GET /api/now/table/incident
  ?sysparm_query=ORDERBYsys_created_on
  &sysparm_display_value=all
  &sysparm_exclude_reference_link=true
  &sysparm_limit=1000
  &sysparm_offset=0

Then the same call with sysparm_offset=1000, 2000 and so on. Four rules keep it complete:

  1. Sort on a stable field. Order by sys_created_on (or sys_id) so records do not shift between pages while agents keep working.
  2. Do not trust a huge page. ServiceNow's Table API reference warns that unusually large sysparm_limit values can affect performance. Pages of 1,000 to 2,000 rows are a common choice.
  3. Offsets slow down on big tables. A ServiceNow Community answer recommends keyset paging for very large tables: filter on sys_created_on greater than the last value you received, instead of an ever-growing offset.
  4. Pull related tables the same way. Query sys_journal_field with element_id in your ticket sys_ids, sys_audit with documentkey, and sys_attachment with table_sys_id.

How many API calls does a full export take?

Divide each table's row count by your page size, then add one call per attachment file. Then divide the total by the hourly limit your instance enforces. ServiceNow applies rate limits through rules in the sys_rate_limit_rules table, set per hour for all users, a role or a single user, and it does not document one default for every instance.

Here is a worked example. The volumes and the rate limit rule are illustrative; replace them with your own counts.

DataRowsPage size (sysparm_limit)Calls
Incidents1,200,0001,0001,200
Journal entries (about 6 per ticket)7,200,0001,0007,200
Audit rows (about 20 per ticket)24,000,0001,00024,000
Attachment metadata300,0001,000300
Attachment files (one call per file)300,000n/a300,000
Total332,700

Under a rate limit rule of 5,000 requests per hour for the export user, 332,700 calls take about 66.5 hours, close to three days of non-stop running. Two things stand out:

  • Attachments dominate. Files are one call each, so they are about 90% of the calls in this example. Count sys_attachment rows before anything else.
  • Bigger pages help less than you think. Raising sysparm_limit to 10,000 cuts the table calls from 32,700 to 3,270, but the 300,000 file calls stay, and very large pages can time out.

When a request is over the limit, ServiceNow returns HTTP 429 Too Many Requests with an X-RateLimit-Reset header giving the reset time, plus X-RateLimit-Limit and X-RateLimit-Rule. Your script must wait and retry, not skip. ServiceNow's docs also say request counts are committed every 30 seconds, so a new rule can take up to 30 seconds to take effect. Admins report hitting 429 errors from concurrency even under a high hourly rule, so keep parallel threads modest.

What do you get from ServiceNow at contract end?

ServiceNow's standard terms, as published in public-sector listings such as the UK G-Cloud marketplace, say ServiceNow exports the entire database in MySQL format, the customer can FTP the files, and ServiceNow keeps customer data for up to 45 days after the contract ends before removing it. Your contract may differ, so check it.

The same listing offers one extension of the subscription for up to six months, prepaid at the expiring monthly fee plus 10%. That extension is often cheaper than trying to work with the dump afterward, because the dump is raw:

  • It does not open like a ServiceNow instance. One ServiceNow Community user who imported a decommissioned instance's MySQL files into a local MySQL install hit error 1069 ("too many keys specified") and could not recover the data.
  • Attachments are chunks. Files sit in sys_attachment_doc and must be decoded and reassembled, then re-linked to tickets through sys_attachment.
  • References are sys_ids. Every assignee, group and category is an ID you must resolve against sys_user, sys_user_group and sys_choice.
  • Nobody can check it against the live instance. Once the instance is gone, there is no way to confirm a record or a file is complete.

The safest plan is to export from the live instance while you still have it, and treat the contract-end dump as a backup.

Pre-export checklist

Run this before the first call. It decides how long the export takes and what it will miss.

  • Count every table in scope. Tickets by table, sys_journal_field rows, sys_audit rows, sys_attachment rows and total attachment size.
  • List the task tables you actually use. Incidents, requested items, catalog tasks, changes, problems, plus custom tables extending task.
  • Create a dedicated export user with read access to every table in scope, so its rate limit rule and audit trail are separate.
  • Check sys_rate_limit_rules for rules that apply to that user or its roles. The lowest applicable count wins.
  • Record the export properties (glide.ui.export.limit and the format-specific ones) before and after any change, and get change approval if you raise them.
  • Decide on display values. Use sysparm_display_value=all so you keep both the sys_id and the label.
  • Include departed users and inactive groups, or their history resolves to blank names.
  • Check glide.sys.audit_inserts so you know whether creation events exist in sys_audit.
  • Agree a file size rule for attachments larger than the target system accepts.
  • Plan a delta. Export by sys_updated_on so records changed after the bulk run are picked up before cutover.
  • Note your contract end date and the 45-day window in your contract, if it has one.
  • Reconcile counts per table, journal entries per ticket and files per ticket, source against export. Our guide to data migration validation lists the checks.

Proof: full ServiceNow history, moved

Covia, an industrial minerals company in the US and Mexico, moved from ServiceNow to Freshservice with MigrateX: more than 1.03 million records with full history, more than 369,000 of them in one weekend, covering nine years of history in English and Spanish. Gary Huck, Service Desk Supervisor at Covia: "If we'd done it ourselves, we'd be looking at months just for the data export, let alone ingesting and translating it." Read the Covia story.

Metro Systems, an IT services partner in Thailand, delivered a ServiceNow to Freshservice move for a publicly listed energy group through us: 19,970 records in a full run of 136 minutes. Read the Metro Systems story.

How MigrateX handles a ServiceNow export

MigrateX is an AI migration platform, and ITSM experts review every step. For a ServiceNow export or exit, that means:

  • Every table, joined back together. We read tickets, sys_journal_field, sys_audit and attachments, and rebuild each record with its conversation, field history and files, keeping original authors and timestamps.
  • Inside your rate limits. We size the job from your table counts and your sys_rate_limit_rules, and back off on 429 responses instead of dropping records.
  • Proof before you pay. A free sample of 100 of your records, then a fixed quote within 24 hours.
  • Any destination. Another ServiceNow instance (instance-to-instance moves are supported), Freshservice, Jira Service Management or an archive. We have 191 connectors, all live, and build new ones in 2 to 3 days. See the ServiceNow platform page and routes such as ServiceNow to Freshservice and ServiceNow to Jira Service Management.
  • Reconciled, with a rollback plan. We count every record source to target and hand over a reconciliation report; every production cutover has a rollback plan. We deliver 100% data fidelity and have completed 1,000+ migrations.
  • For partners. Systems integrators and MSPs can run the export under their own brand with our white-label delivery.
  • Security. MigrateX is SOC 2 Type II, GDPR and HIPAA compliant, with a DPA available (see security).

If your instance sits inside an MSP's shared, domain-separated platform, read our guides on leaving a Kyndryl-hosted ServiceNow with your data and domain-separated ServiceNow migrations. Consolidating two instances instead? See how to merge ServiceNow instances.

What to have ready for the call

You do not need all of this, but each item makes the quote faster and firmer:

  • Your instance's release family (for example, Yokohama or Zurich)
  • Tables in scope and rough record counts per table
  • Rough count and total size of attachments
  • Years of history you need to keep
  • Where the data is going: another tool, another instance or an archive
  • Your contract end date or go-live date
  • One table and a date range for the free 100-record sample

Facts checked November 11, 2026 from ServiceNow docs: Export limits, ServiceNow docs: Export directly from a URL, ServiceNow docs: Export sets, ServiceNow docs: Table API, ServiceNow docs: Inbound REST API rate limiting, ServiceNow docs: Attachment API, ServiceNow docs: Attachment limit properties, ServiceNow terms as published on the UK G-Cloud marketplace, ServiceNow Community: viewing data from an expired instance, ServiceNow Community: when sys_journal_field is included in XML and Fivetran docs: missing sys_history_line updates. No vendor paid for this article. How we research

ServiceNow data export FAQ

How do I export more than 10,000 records from ServiceNow?

Either raise the export limit properties, export in batches with filters, or use the Table API. An admin can raise glide.ui.export.limit or a format-specific property under System Properties > Import Export, with a performance warning from ServiceNow. For a complete export, page through the Table API with sysparm_limit and sysparm_offset, which pages through the whole table.

How do I export ServiceNow data to Excel?

Right-click a list column header, choose Export, then Excel. The export includes only the columns in the current view and stops at the export limit, 10,000 rows by default, and Excel exports are also capped at under 500,000 cells. Excel suits reports. For a migration or archive, use the Table API instead.

How do I export work notes and comments from ServiceNow?

Export the sys_journal_field table, filtered by name (the ticket's table) and element (work_notes or comments). Each row is one entry with its author and time, and element_id is the parent ticket's sys_id. A list export of the ticket table does not give you these as separate, dated entries.

How do I export attachments from ServiceNow?

List the files from sys_attachment filtered by table_name and table_sys_id, then download each one with the Attachment API (GET /api/now/attachment/{sys_id}/file, using the attachment's sys_id). The file data itself is stored in 4 KB chunks in sys_attachment_doc, which is why list and XML exports do not include files.

Does the ServiceNow Table API have a rate limit?

Rate limits are set per instance through rules in sys_rate_limit_rules, counted per hour for all users, a role or a single user. ServiceNow does not publish one default that applies everywhere. Over the limit, the API returns HTTP 429 with an X-RateLimit-Reset header, so check the rules that apply to your export user before sizing the job.

Can I export audit history from ServiceNow?

Yes, from the sys_audit table, where documentkey is the record's sys_id and each row holds the field name, old value, new value, user and time. Do not rely on sys_history_line: those rows are built only when someone views a record's history. sys_audit can be very large, so count it first.

What happens to my ServiceNow data when the contract ends?

Under ServiceNow's standard terms as published in public-sector listings, ServiceNow exports the full database in MySQL format for you to download by FTP and removes data after up to 45 days. The dump is raw tables, not a working instance, so export from the live instance first and check the terms in your own contract.

Changelog

  • 11 Nov 2026: First published.

Written by

Ayush Bothra

Founding Member, MigrateX

Ayush writes about ITSM platforms, pricing and what it takes to move a service desk to a new platform without losing its history.