---
title: "How to Export Data from Loxo: Methods, API Limits & Portability"
slug: how-to-export-data-from-loxo-methods-api-limits-portability
date: 2026-07-31
author: Roopi
categories: [Loxo]
excerpt: "Export data from Loxo via CSV, API, or support request. Learn what each method covers, what's missing, rate limits, and how to plan a full migration."
tldr: "Loxo's native CSV export only includes visible List-view fields. Full export requires the paid API, support assistance at contract end, or a managed service."
canonical: https://clonepartner.com/blog/how-to-export-data-from-loxo-methods-api-limits-portability/
---
# How to Export Data from Loxo: Methods, API Limits & Portability
# How to Export Data from Loxo: Methods, API Limits & Portability
> [!NOTE]
> **TL;DR — Loxo Data Export**
>
> You cannot self-serve a full data export from Loxo. The native UI CSV export only includes fields visible in your current List view and excludes resumes, activity history, work experience, education profiles, and attachments. The Open API covers People, Companies, Jobs, and dynamic fields, but API access is a paid add-on and Loxo does not publish numeric rate limits. Loxo Source profiles are restricted to `person_name`, `person_id`, and custom fields only, capped at 500 profiles per rolling 30 days. A comprehensive data export covering all objects is only available by contacting Loxo Support, and it is gated behind contract termination. For anything beyond flat candidate/company lists, plan for engineering resources or a managed migration service.
>
> **Last verified:** July 2025. Loxo's API documentation does not use version numbers or changelogs — confirm endpoint behavior against your own tenant before relying on any specifics below.
> [!NOTE]
> **Disclosure:** This guide is published by ClonePartner, a managed ATS migration service. We have a commercial interest in readers concluding that Loxo exports are complex enough to warrant external help. Every factual claim below is sourced from Loxo's public documentation or empirical testing. Where a claim is an estimate rather than a confirmed figure, it is labeled as such. You can verify the core claims yourself using the methods described.
## What Data Can You Export from Loxo?
Loxo is a **Talent Intelligence Platform** that combines ATS, Recruiting CRM, sourcing, and outreach into a single product. Its core data model spans People (Candidates and Contacts), Companies, Jobs, Activities, Deals, Placements, and enriched source data from Loxo's proprietary 800M+ profile database (Loxo Source).
The exportability of each object depends on your extraction method. No single method gives you everything.
| Object | Native UI CSV Export | API Export | Full Data Export (Support) | Format | Known Limitations |
|---|---|---|---|---|---|
| People (Candidates/Contacts) | Yes | Yes (`/people`) | Yes | CSV / JSON | CSV only includes fields visible on the List view; resumes, activity history, work experience, education profiles excluded |
| Companies | Yes | Yes (`/companies`) | Yes | CSV / JSON | Same List-view-only field constraint |
| Jobs | Partial (via pipeline export) | Yes (`/jobs`) | Yes | CSV / JSON | Job-specific data available via Reports export; full job data export only available at contract termination |
| Activities / Activity Feed | No | Via `/activity_types` (types only) | Yes | JSON | No native UI export; per-candidate activity history not available via self-serve |
| Deals | No | Via webhooks (create/update/destroy) | Yes | JSON | No dedicated list endpoint documented in Open API; webhook payload schema not publicly documented |
| Placements | No | Via webhooks only | Yes | JSON | No GET endpoint in public API docs; webhook payload schema not publicly documented |
| Resumes / Attachments | No (individual download only) | Not documented for bulk download | Yes | PDF / files | Must be exported individually from each profile |
| Education Profiles | No | Not in Open API | Yes | — | Silently excluded from CSV exports |
| Work Experience | No | Not in Open API | Yes | — | Silently excluded from CSV exports |
| Email Logs | Yes (date-range filtered) | No | Yes | CSV | Must set date range manually; no bulk API endpoint |
| Reports | Yes | No | — | CSV | Reports built within Loxo's Reports Dashboard are exportable as CSV |
| Custom Fields (Dynamic Fields) | In CSV (if visible) | Yes (`/dynamic_fields`) | Yes | CSV / JSON | Only fields toggled on in List view appear in CSV |
| Loxo Source Profiles | Capped | Capped | — | CSV / JSON | Limited to `person_name`, `person_id`, and custom field results; 500-profile export cap per 30 rolling days |
> [!WARNING]
> **[For engineering]** The silent failure mode in Loxo's native export is column omission. If a field is not visible on the People or Companies grid when you export, it is not in the CSV. That matters for custom fields, ownership fields, and any downstream mapping you plan to automate. If you are scoping a migration, the CSV alone will produce a flat, incomplete dataset. Additionally, the API does not expose a `deleted_at` field or return soft-deleted records — once a record is deleted via the UI, it is gone from API responses as well. There is no recovery window accessible through the API.
## How Loxo Compares to Other ATS Platforms on Export Completeness
Loxo's export restrictions are not unusual in the ATS market, but the specifics vary significantly across platforms. The following comparison is based on each platform's publicly documented export capabilities as of July 2025.
| Capability | Loxo | Bullhorn | Greenhouse | Lever |
|---|---|---|---|---|
| **Self-serve full data export** | ❌ (contract termination only) | ✅ (Mass Update / data export tools) | ✅ (Harvest API covers most objects) | ✅ (data export available in settings) |
| **API access included in base plan** | ❌ (paid add-on) | ❌ (varies by plan) | ✅ (Harvest API included) | ✅ (included for most plans) |
| **Published rate limits** | ❌ (undisclosed) | ✅ (documented per-endpoint) | ✅ (10 requests/10 seconds per user) | ✅ (10 requests/second) |
| **Bulk attachment/resume export** | ❌ | ✅ (via API) | ✅ (via API) | ✅ (via API) |
| **Activity history via API** | ⚠️ (types only, not per-candidate) | ✅ | ✅ | ✅ |
| **Relationship data in export** | ❌ (flat CSV; API has partial linking) | ✅ (relational IDs) | ✅ (relational IDs) | ✅ (relational IDs) |
| **Export gated behind contract status** | ✅ (full export requires termination) | ❌ | ❌ | ❌ |
This comparison clarifies what "Partially Locked" means for Loxo's portability: the restrictions are not about missing an export button — they are about the combination of paid API access, undisclosed rate limits, absent bulk attachment export, and a full data export that requires contract termination. Most competing platforms do not gate comprehensive data access behind subscription status.
## Export Methods: Every Way to Get Data Out of Loxo
Loxo has four real export paths: admin CSV export, Reports/Email Log export, the Open API, and a Support-assisted full export tied to contract termination. There is also a published-jobs XML feed, but that is a job-board distribution mechanism, not a portability method.
| Method | Data Coverage | Volume Limit | Speed | Complexity | Best For |
|---|---|---|---|---|---|
| Native UI CSV Export | People, Companies, Job Pipeline candidates, visible fields only | ~15,000 before restrictions; Loxo Source capped at 500/30 days | Minutes | Low | Quick lists, ad-hoc reports |
| Reports / Email Log Export | Pipeline metrics, activity reports, email audit trail | Report-dependent; email log is date-range filtered | Minutes | Low | Operational reporting, compliance slices |
| Open API | People, Companies, Jobs, Dynamic Fields, Activity Types, Job Tags | No documented cap; Loxo Source limited | Hours (depends on volume) | Medium–High | Integration, migration, continuous sync |
| Full Data Export (Support) | All objects including attachments and history | Full account | Days to weeks (estimated — see note below) | Low (for you) | Contract termination, full migration |
| Managed Migration Service | Full fidelity, including attachment handling and relationship mapping | Unlimited | Fastest route to migration-grade output | Low for the client | Companies switching ATS platforms that cannot afford data loss |
**[For PMs]** The only zero-engineering option is the native UI CSV export, and it covers a narrow slice of your data. Any export that includes activity history, resumes, or relational data requires either API development, a Support-assisted full export, or a managed service.
## How to Export People and Companies from Loxo (Step-by-Step)
Exporting to CSV is a function reserved for agency admins. Non-admin users will not see the Export button.
1. Navigate to the **People** or **Companies** page in Loxo.
2. Switch to **List view**. Only columns visible in the grid will be included in the export — toggle on every built-in and custom field you need *before* exporting.
3. Select individual records using checkboxes, or click **"Select All"** → **"Select XXX people from all pages"** for bulk selection.
4. Click the **"Export"** button in the upper-right corner.
5. Choose **"Export selected."**
6. A CSV file will be emailed to the address associated with your Loxo login.
**What's included:** Built-in and custom fields that are currently displayed on your List view grid.
**What's missing:** Resumes, activity feed history, work experience history, education profiles, forms, documents, and attachments are all excluded. This is a flat-record export, not a backup or migration package.
> [!WARNING]
> **Large export restriction:** For exports exceeding 15,000 contacts, Loxo may restrict exporting to one page at a time. Users requiring a complete export should contact Loxo's Support Team.
### Exporting Job Pipeline Candidates
Open the Job Pipeline → switch from Kanban view to List view → select candidates → click "Export" to generate a CSV. This gives you candidates associated with a specific job, but still only includes visible List-view fields — not a full application history.
### Exporting Email Logs
Email history has its own export path. Navigate to your Email Log (click the three dots in the navigation → Email Log). Set a date range, apply filters, and click **"Export."** This produces a CSV of email activity useful for outreach auditing or compliance, but it is not a full conversation-model export.
### Exporting Reports
Reports built within Loxo's Reports Dashboard are exportable as CSV. This covers pipeline metrics and activity-based KPIs, not raw record-level data.
### Use Boolean Search Before You Export
Loxo supports Boolean search on People, Jobs, and Companies. Fielded search uses a no-space-after-colon syntax:
```text
current_title:"VP of Sales" AND owner:"Jane Doe"
```
This is the fastest way to cut down export noise before pulling a CSV.
## API-Based Export [For Engineering]
The Open API is the only self-serve path to structured, programmatic data extraction from Loxo. Loxo built the Open API for custom integrations — whether for job listings, custom reporting, VOIP services, user analytics, data cleanup, or contact validation. It is strong enough for People, Companies, Jobs, dynamic fields, and tags, but the public docs do not describe a complete bulk-backup route for files, full activity history, or whole-account offboarding.
### Authentication and Access
All endpoints use bearer token authentication. Generate a key in Settings → API Keys. Only account admins can access the API Keys page.
**API access is a paid feature.** If you don't have an active paid subscription, the API is not available. Loxo does not publish API add-on pricing on its website — contact Loxo Sales for current rates. Some accounts may need to contact Loxo Support to enable the API Keys page.
### Endpoint URL Format
All API calls follow this pattern:
```
https://{domain}/api/{agency_slug}/{endpoint}
```
Your `domain` and `agency_slug` are provided by Loxo Support.
> [!CAUTION]
> **Undocumented endpoint trap:** Some endpoints, such as `/api/v1/people` and `/api/v1/jobs`, are not part of the Loxo Open API. Attempting to call these endpoints will result in a 403 error. Always use the `/{agency_slug}/` URL format — not the `/v1/` pattern you might see referenced in third-party guides.
### Available Endpoints
Based on Loxo's official documentation, the Open API exposes these endpoints:
| Endpoint | Methods | Use Case |
|---|---|---|
| `/people` | GET, POST | List/search people, create person |
| `/people/{id}` | GET, PUT | Get/update specific person |
| `/companies` | GET, POST | List/search companies |
| `/companies/{id}` | GET, PUT | Get/update specific company |
| `/jobs` | GET, POST | List/search jobs |
| `/jobs/{id}` | GET | Get specific job details |
| `/jobs/{job_id}/apply` | POST | Submit candidate to a job |
| `/activity_types` | GET | List pipeline progression triggers |
| `/dynamic_fields` | GET | List custom fields with types |
| `/job_categories` | GET | List job tags |
| `/compensation_types` | GET | List salary types |
| `/forms/{id}` | GET | Get an individual form response |
| `/webhooks` | GET, POST | Manage webhooks |
| `/loxo_source/people` | GET | Search Loxo Source directory (`page`/`per_page` pagination, Boolean query) |
### Webhook Events and Payload Limitations
The API supports webhooks for the following events: People (create/update/destroy), Companies (create/update/destroy), Jobs (create/update/destroy), Deals (create/update/destroy), and Placements (create/update/destroy). However, Loxo's public documentation does not publish the full payload schema for any webhook event. This means developers building a Deals or Placements export pipeline — the only objects where webhooks are the sole retrieval mechanism — must register a webhook endpoint, trigger test events, and inspect the actual payloads to determine which fields are included. Plan for a discovery phase if you depend on webhook-sourced data for migration or integration.
### Pagination and Rate Limits
Loxo does not publicly document specific rate limits (requests per minute or per day) in its API reference. Its Terms of Service state it may place limits on API calls and reduce access if usage affects security or service integrity. You must discover throttle thresholds empirically or request them from Loxo Support. Expect HTTP 429 responses if you hit the undisclosed ceiling.
**Pagination:** The API supports `query` parameters for searching on People, Companies, and Jobs endpoints. The one public example with explicit pagination details is `/loxo_source/people`, which uses `page` and `per_page` with page numbering starting at 1. Pagination behavior for other endpoints (including `/people` and `/companies`) is not formally documented in the public API reference.
**Important caveat for the sample script below:** The `page` parameter in the `/people` endpoint is used based on the pattern documented for `/loxo_source/people`. It has not been confirmed in Loxo's public documentation for this specific endpoint. Before building a production export pipeline, test a single paginated request against your own tenant to confirm the response structure — specifically whether the API returns a bare JSON array, a paginated envelope with metadata (e.g., `total_count`, `total_pages`), or something else entirely. The sample script assumes an empty array signals the final page; adjust if the API returns a wrapper object.
Implement conservative request spacing (1–2 requests per second) and exponential backoff on 429 responses. There is no vendor-backed records-per-hour figure to publish here. If you need a precise export window, benchmark your own tenant after API access is enabled and before you commit to a cutover date.
### Loxo Source API Restrictions
Profiles obtained from Loxo Source contain proprietary data and are limited to `person_name`, `person_id`, and custom field results. Data that users bring into their database is always theirs to retrieve. The 500-profile-per-30-days export cap applies universally across the platform and cannot be bypassed through the API.
### Sample Export Script
```python
import requests
import time
import json
BASE_URL = "https://{domain}/api/{agency_slug}"
HEADERS = {
"accept": "application/json",
"authorization": "Bearer {API_KEY}"
}
def export_all_people():
"""
Export all People records from Loxo via the Open API.
IMPORTANT: The `page` parameter behavior for /people is inferred
from the /loxo_source/people documentation. Test against your tenant
to confirm pagination works as expected before running at scale.
The script assumes an empty response body (empty array) signals
the last page. If the API returns a wrapper object, adjust the
empty-check logic accordingly.
"""
page = 1
all_people = []
while True:
resp = requests.get(
f"{BASE_URL}/people",
headers=HEADERS,
params={"page": page, "per_page": 100}
)
if resp.status_code == 403:
raise Exception(
"403 Forbidden — likely wrong endpoint path "
"(check /agency_slug/ vs /v1/), missing API entitlement, "
"or invalid token"
)
if resp.status_code == 429:
retry_after = int(resp.headers.get("Retry-After", 60))
print(f"Rate limit hit. Sleeping for {retry_after}s...")
time.sleep(retry_after)
continue
if resp.status_code != 200:
raise Exception(f"API error: {resp.status_code} - {resp.text}")
data = resp.json()
# Adjust this check if the API returns a wrapper object
# instead of a bare array
if not data:
break
if isinstance(data, dict):
# Handle potential wrapper: data might be in a key like "people"
records = data.get("people", data.get("data", []))
if not records:
break
all_people.extend(records)
else:
all_people.extend(data)
page += 1
time.sleep(1) # Conservative spacing; Loxo does not publish numeric limits
return all_people
if __name__ == "__main__":
people = export_all_people()
with open("loxo_people_export.json", "w") as f:
json.dump(people, f, indent=2)
print(f"Exported {len(people)} people records")
```
> [!TIP]
> Treat `403` and throttling as different problems. Loxo explicitly says unsupported `/api/v1/` paths return `403`, so fix pathing and entitlements before you assume rate limiting. A `403` means the endpoint does not exist for your account at that URL — a `429` means you're hitting the undisclosed rate ceiling.
## Does Loxo Let You Export Attachments and Resumes?
Not in bulk. Loxo's export documentation states that resumes, forms, documents, and other attachments must be exported individually from each candidate profile. There is no native bulk attachment export in the UI and no documented API endpoint for batch file downloads.
For migration scenarios, this means:
- Each resume must be opened and saved manually from the candidate profile, **or**
- A developer must build a per-person API loop that fetches profile details via `GET /people/{id}` and extracts file URLs (if exposed in the person detail response — this is not confirmed in public docs), **or**
- You request a full data export from Loxo Support, which typically includes attachments when provided at contract termination
Third-party unified API platforms like Truto expose Attachments as a resource in their ATS integration for Loxo, which may simplify programmatic extraction if direct API access falls short.
**If you are writing a custom downloader:** Prepend the Candidate ID to each filename (e.g., `1048593_john_doe_resume.pdf`). Without this, you will end up with thousands of files named `resume.pdf` with no way to link them back to the correct candidate in your destination system.
## What Data Cannot Be Exported from Loxo?
Some gaps are explicit in Loxo's own docs. Others are better described as not publicly documented for self-serve export. That distinction matters when building a migration plan or negotiating renewal leverage.
**Explicitly excluded or restricted:**
| Data Type | Self-Serve Export? | Workaround |
|---|---|---|
| Activity Feed History (per candidate) | ❌ Not via UI or API | Request full data export from Support |
| Work Experience Profiles | ❌ Not in CSV; not in Open API | Full data export only |
| Education Profiles | ❌ Not in CSV; not in Open API | Full data export only |
| Resumes & Attachments (bulk) | ❌ No bulk export | Individual download or full data export |
| Loxo Source Enriched Data | ⚠️ Capped at 500/30 days | Only `person_name`, `person_id`, custom fields |
| Deleted Records | ❌ Permanently removed | No recovery; no `deleted_at` field in API |
**Not publicly documented as self-serve exportable:**
- System audit logs (IP addresses, login history, record modification logs)
- User permissions and role assignments
- Saved views, searches, and grid configurations
- Outreach sequences, email templates, and automation/workflow rules
- Pipeline stage configurations
- Integration settings and API key configurations
- Bulk deals or placements (webhook-only in the public API; payload schemas undocumented)
- Webhook payload schemas for any event type
> [!CAUTION]
> **Data purge policy:** A full data export is only available at the termination of a contract. Data is securely removed 30 days after non-renewal. Deleting a person or company record is permanent — it removes associated notes, activities, resumes, and profile data, and cannot be reversed by Support. The API does not expose soft-deleted records or a recycle bin. Export before you delete or cancel.
## Data Format, Encoding, and Post-Export Cleanup
Loxo UI exports produce **CSV files encoded in UTF-8**. The API returns **JSON**. There is no native XML, XLSX, or database-dump export option. (Loxo does expose an XML feed for published jobs, but that is for job-board distribution, not operational data.)
When importing Loxo CSVs into Excel, explicitly set the file origin to UTF-8 (code page 65001) and the delimiter to comma — otherwise special characters (accented names, non-Latin scripts) will render incorrectly.
**Common issues after export:**
- **Missing relationships:** CSV exports are flat. People-to-Company, Candidate-to-Job, and Deal-to-Placement relationships are not preserved as foreign keys. The API may return relational IDs (e.g., a `company_id` on a Person record), but this is not confirmed for all objects in the public docs.
- **No internal IDs in CSV:** Loxo internal record IDs may not appear in CSV exports unless the field is toggled on in List view before exporting.
- **Orphaned custom fields:** Dynamic fields only export if visible in the grid. Hidden custom fields are silently dropped.
- **HTML in text fields:** Notes and descriptions may contain raw HTML markup (``, ``, `![]()
`) that appears as broken tags in CSV or plain-text imports. Strip these tags before import if your destination system does not render HTML.
- **Timezone normalization:** Verify that exported timestamps align with your destination system's expected format (e.g., ISO 8601). Loxo does not document which timezone its exports use by default.
- **Duplicate candidates:** ATS data is notorious for duplicate records. Resolve these in the exported dataset *before* importing elsewhere. Deduplicate on email address first, then name + phone as a secondary key.
**[For PMs] Post-export validation checklist:**
1. Verify record count matches source (People page total vs. CSV row count)
2. Spot-check 10 random records for field completeness — compare CSV columns against the full profile in the Loxo UI
3. Confirm all needed custom fields were toggled on in List view before export
4. Check for encoding issues in names with special characters
5. Validate that Loxo Source profiles are within the 500-per-30-day cap
6. Reconcile attachments as a separate count — they are not part of the CSV
7. Track People-to-Company and Person-to-Job relationships with an ID map
8. Verify that no fields were silently dropped by re-exporting a 10-record sample with all columns visible
## Export for Migration vs. Backup vs. Compliance
Your export strategy must match your objective. The right method and acceptable data gaps change depending on what you are trying to accomplish.
### Migration
You need full relational data — People linked to Companies, Candidates linked to Jobs and pipeline stages, activity history, and attachments. The native CSV export is insufficient. You need the API for structured data, plus a support-assisted full export for attachments and history. Build an [ID-mapping table](https://clonepartner.com/blog/blog/loxo-to-loxo-migration-the-ctos-technical-guide/) to re-link relationships in the target system. Every exported candidate, job, and user has a unique Loxo ID — maintain a mapping table (Loxo ID → Destination ID) so that when you import historical notes, they attach to the correct record.
### Backup
A periodic CSV export captures a snapshot of visible fields, but it is not a full-fidelity backup. There is no native scheduled export or backup feature in Loxo. The full export route is tied to contract termination, so teams that need ongoing backup should build a scheduled API extraction process (e.g., daily cron job pulling `/people` and `/companies`) plus manual attachment archival rather than relying on the offboarding workflow.
### Compliance (GDPR/CCPA)
If a candidate submits a Data Subject Access Request (DSAR), you must provide all their data within the regulatory timeframe (30 days under GDPR, 45 days under CCPA). Loxo supports candidate-level [GDPR workflows](https://clonepartner.com/blog/blog/ats-migration-gdpr-ccpa-compliance/) — candidates can request a copy of their data, update information, or ask to be removed, and admins can manage those requests from the profile or GDPR Search page. The native UI CSV often misses internal notes and activities, so a fully compliant dossier likely requires combining UI exports with API calls.
**Data Processing Agreement (DPA):** Loxo's privacy documentation references GDPR compliance, but the availability and terms of a signed DPA, the sub-processor list, and data residency options (e.g., EU vs. US hosting) are not published on Loxo's public-facing website as of July 2025. If your organization requires a DPA for compliance, request one directly from Loxo's legal team before signing or renewing. Confirm data residency and sub-processor commitments in writing.
Loxo states that data users bring into their database is always theirs to retrieve — but the mechanisms to retrieve it comprehensively are limited, and a DSAR response assembled solely from CSV exports may be incomplete.
## How Portable Is Loxo Data? [For CTOs]
**Portability rating: Partially Locked.** This rating is based on five dimensions evaluated against comparable ATS platforms (Bullhorn, Greenhouse, Lever):
| Dimension | Loxo | Typical ATS Benchmark |
|---|---|---|
| Self-serve full export without contract action | ❌ | ✅ (Greenhouse, Lever, Bullhorn) |
| API access included in standard plans | ❌ (paid add-on) | Mixed (Greenhouse ✅, Bullhorn varies) |
| Published, numeric rate limits | ❌ | ✅ (Greenhouse: 10/10s, Lever: 10/s) |
| Bulk attachment export via API | ❌ | ✅ (all three competitors) |
| Activity history export via API | ⚠️ (types only) | ✅ (all three competitors) |
| Relational IDs in standard exports | ⚠️ (API partial, CSV no) | ✅ (all three competitors) |
**What you can get out cleanly:** Flat People and Company records (visible fields only) via CSV; structured People, Company, and Job data via API.
**What requires engineering:** Relationships between objects must be reconstructed. Activity history and pipeline stage associations are not available via self-serve export. Attachments require individual extraction or a support-assisted full export.
**What is lost or restricted:** Loxo Source enrichment data is proprietary and capped. Workflow configurations, outreach templates, saved views, and automation rules have no export path.
**Contractual constraint:** A full data export is only available at the termination of a contract. Comprehensive data access is tied to your subscription status.
The real switching cost is not finding the export button — it is the engineering time required to reconstruct relationships, extract attachments one by one, and supplement CSV exports with API calls to achieve full coverage. Teams without developers are effectively dependent on the Support-assisted full export at contract end, or they need to bring in external help.
## Timeline and Resourcing for a Full Data Export [For PMs]
The timelines below are **estimates based on migration project experience**, not confirmed SLAs from Loxo. Support response times vary by account tier and contract status. Request an explicit timeline commitment from Loxo Support before building your cutover plan around these figures.
| Dataset Size | UI CSV Export | API Export | Support Full Export (estimated) |
|---|---|---|---|
| Small (<10K records) | 10–30 minutes | 2–4 hours (with script) | 3–7 business days |
| Medium (10K–100K) | May hit 15K page restriction | 4–12 hours | 5–14 business days |
| Large (100K+) | Requires Support assistance | 12–48 hours | 2–4 weeks |
**Minimum team composition:**
- **UI CSV only:** 1 admin user, no developer needed
- **API export:** 1 developer (Python/Node.js) + 1 PM for validation. Budget 1–2 days for endpoint discovery and pagination testing before writing production scripts.
- **Full migration (with attachments + relationships):** 1–2 developers + 1 PM + Loxo Support coordination. Budget additional time for webhook payload discovery if Deals or Placements data is required.
If you are planning a destination migration, pair this guide with the [ATS data migration checklist](https://clonepartner.com/blog/blog/the-ultimate-ats-data-migration-checklist-a-10-point-plan-for-a-compliant-transition/) and the [GDPR/CCPA compliance guide for ATS migrations](https://clonepartner.com/blog/blog/ats-migration-gdpr-ccpa-compliance/) before you lock your cutover plan.
## The Practical Answer
Loxo gives you a real export story for flat, account-owned records. It does not give you a single, self-serve, full-fidelity portability path for everything that matters in a recruiting stack. Among comparable ATS platforms, Loxo's export restrictions — particularly the contract-termination gate on full exports and the absence of published API rate limits — are more restrictive than the market median.
In practice, Loxo exports end up as mixed-mode extractions: API for structured objects, admin CSVs for quick slices, and controlled manual or support-assisted pulls for files and edge-case history. The main risk is not finding the export button — it is missing the fields and relationships the export never carried.
> Planning a Loxo migration or need a full data export? ClonePartner has handled 1,500+ ATS migrations involving complex object relationships, bulk attachment extraction, and custom field mapping at scale. We handle the extraction, mapping, and validation — so your recruiting data arrives intact.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)
## Frequently asked questions
### Can I export all my data from Loxo?
Not through self-serve tools. The native CSV export only includes fields visible in your List view and excludes activity history, resumes, work experience, and education profiles. A full data export covering all objects is only available by contacting Loxo Support, and it is gated behind contract termination.
### Does Loxo export include attachments?
No. Resumes, forms, documents, and attachments must be exported individually from each profile. There is no bulk attachment export in the UI or a documented bulk-download API endpoint. A support-assisted full data export at contract termination may include attachments.
### What format does Loxo export data in?
Loxo UI exports produce UTF-8 encoded CSV files. The Open API returns JSON. There is no native XML, XLSX, or database-dump export option.
### How long does it take to export data from Loxo?
A small CSV export under 10,000 records typically arrives via email within 10–30 minutes. API-based exports take 2–12 hours for medium datasets depending on volume and rate limits. A full support-assisted export can take 3–14 business days.
### What is the Loxo Source export limit?
Each account is limited to exporting 500 Loxo Source profiles per 30 rolling days. Exports only include person_name, person_id, and custom field values. This cap applies universally and cannot be bypassed through the API.