How to Export Data from Charlie (CharlieHR): Methods, API & Limits

How to Export Data from Charlie (CharlieHR): Methods, API & Limits

Charlie (formerly CharlieHR) is an HRIS platform built for UK-based small businesses with roughly 10–250 employees. Its data model centers on Team Members, Salaries, Time Off, Documents, Performance Reviews, Engagement Polls, Teams, Offices, Custom Cards, Key Dates, Onboarding/Offboarding Checklists, and the Company Handbook. When it comes time to migrate to a mid-market or enterprise HRIS — BambooHR, Workday, Rippling — you will find that getting structured text data out is straightforward, but extracting documents, reviews, and configuration-level objects requires extra effort.

This guide covers exactly what you can extract, every export method available, the API endpoints and their constraints, and the known gaps in Charlie's data portability. It covers the core Charlie HRIS, not the separate Charlie Recruit add-on. (Charlie Recruit has its own candidate data store; if you use it, plan a separate extraction — Recruit's export paths are not covered here.)

What Data Can You Export from Charlie?

Before planning an extraction, map Charlie's data model. The exportability of each object depends entirely on which method you use. No single method covers everything. (help.charliehr.com)

Fully exportable: core structured HR data — team members, payroll fields, leave records, teams, offices, working locations. Partially exportable: documents, reviews, polls, checklists, and handbook content — they exist in the GDPR export but not in a clean public API. Not cleanly exportable: the org chart visual layout and individual diversity responses.

[For engineering] The API omits documents, performance reviews, engagement polls, custom cards, onboarding checklists, and handbook content entirely. If you need these objects programmatically, the GDPR export XML is your only extraction path — and it requires custom parsing.

How Charlie Compares: Export Portability vs. Other SMB HRIS Platforms

Charlie's export capabilities are typical for a sub-250-employee HRIS but lag behind some competitors in API breadth and document handling. This comparison covers the core export dimensions that matter for migration planning.

Key takeaway: Charlie's structured HR data exports cleanly via CSV and API, matching its SMB peers. The gaps that create migration friction — no document API, no webhooks, undocumented rate limits, 25-record pagination cap — are areas where BambooHR, Personio, and HiBob offer more mature developer tooling. The GDPR full-account XML export partially compensates by covering objects the API misses, but it requires custom XML parsing that the other platforms' APIs make unnecessary.

Export Methods: Every Way to Get Data Out of Charlie

Charlie offers three native extraction paths — Reports (CSV), the full GDPR account export (XML), and the REST API (JSON) — plus third-party integration options. No single method covers 100% of the data model. (help.charliehr.com)

[For PMs] Reports Export, feature-specific CSV exports, and the GDPR Export require zero engineering — any Super Admin or Admin can do them from the Charlie UI. The API route requires a developer.

How to Export Employee Data from Charlie's UI (Step-by-Step)

Permissions matter: company CSV exports are limited to Super Admins, Admins, and Payroll Admins. The full account export and review export are Super Admin only. (charliehr.com)

Pre-Built Reports Export

1. Log in as a Super Admin, Admin, or Payroll Admin
2. Click the Reports tab in the left navigation
3. Select a pre-built report: Team Member (basic or full), Payroll, Time Off Summary, Time Off Detail, Sick Leave, New Starters & Leavers, Addresses, Emergency Contacts, or Email & Phone Numbers
4. Click "Export Data" — the report downloads as a CSV file
5. Previously exported reports are available at the bottom of the Reports page for re-download — Charlie shows who downloaded them and when

Custom Reports Export

1. Go to Reports → click "New" under Custom Reports
2. Choose report type: Team Member Information or Time Off Trends
3. Select the fields you want to include
4. Optionally toggle "Include archived employees" to capture leavers
5. Name the report, click Save
6. Click "Go to your report" → then "Export Data"

The CSV includes only the fields you selected. You can edit the report later to add or remove fields, then re-export. (help.charliehr.com)

Exporting Completed Reviews

Go to Grow → Reviews → History, open a completed cycle, and click Export Review. Charlie generates a CSV, but the documented export path covers completed review cycles only — in-progress reviews cannot be exported. (help.charliehr.com)

Exporting Poll Responses

Go to Engage → Polls & Surveys, open the poll, switch to Results, and click Export results. The output is CSV, and the export is per poll — there is no single button to export every poll in the account at once. (help.charliehr.com)

Individual Team Member Export

Charlie lets Super Admins and Admins export all data for a single team member as a CSV. Navigate to the team member's profile and use the export option. This is useful for Subject Access Requests (SARs) but impractical for bulk extraction across the full org.

How to Request a Full GDPR Export from Charlie

The GDPR full account export is the most complete extraction method Charlie offers. It produces an XML-based archive containing all company data. (help.charliehr.com)

Steps:

1. Log in as a Super Admin (only Super Admins can trigger this)
2. Navigate to Company Settings
3. Scroll to the "Request full account export" button and click it
4. Wait for the email notification confirming the export is ready
5. Click the link in the email to return to Charlie, then click Download

What you get:

• A file containing various folders plus a company.xml document with the majority of your account data
• Included data: handbook, all leave requests, all documents, salaries, report exports, reviews, polls, checklists, and key dates
• Format: XML
• The export file auto-deletes from Charlie after one week — download it immediately and store it externally

GDPR Export XML Structure (Representative Sample)

The XML schema is not publicly documented by Charlie. Based on actual export inspection, the company.xml file follows a structure similar to this anonymized excerpt:

<?xml version="1.0" encoding="UTF-8"?>
<company>
  <name>Acme Ltd</name>
  <team_members>
    <team_member>
      <id>tm_abc123</id>
      <first_name>Jane</first_name>
      <last_name>Smith</last_name>
      <email>jane.smith@acme.com</email>
      <start_date>2021-03-15</start_date>
      <job_title>Product Manager</job_title>
      <team>Engineering</team>
      <office>London HQ</office>
      <line_manager_email>bob.jones@acme.com</line_manager_email>
      <salaries>
        <salary>
          <amount>55000</amount>
          <currency>GBP</currency>
          <effective_date>2023-01-01</effective_date>
          <pay_period>annually</pay_period>
        </salary>
        <salary>
          <amount>50000</amount>
          <currency>GBP</currency>
          <effective_date>2021-03-15</effective_date>
          <pay_period>annually</pay_period>
        </salary>
      </salaries>
      <custom_cards>
        <card>
          <name>Right to Work</name>
          <fields>
            <field><label>Document Type</label><value>Passport</value></field>
            <field><label>Expiry Date</label><value>2028-06-30</value></field>
          </fields>
        </card>
      </custom_cards>
    </team_member>
  </team_members>
  <leave_requests>
    <leave_request>
      <team_member_id>tm_abc123</team_member_id>
      <leave_type>Holiday</leave_type>
      <start_date>2024-08-05</start_date>
      <end_date>2024-08-09</end_date>
      <status>approved</status>
      <days_used>5.0</days_used>
    </leave_request>
  </leave_requests>
  <handbook>
    <section>
      <title>Working Hours</title>
      <content><![CDATA[Our standard working hours are 9:00–17:30...]]></content>
    </section>
  </handbook>
</company>

Node names generally correspond to Charlie's UI field labels, but nesting depth and attribute names vary by object type. Custom cards use the card name and field labels as defined by the admin who created them — there is no standardized schema across accounts. Budget 2–4 hours of schema mapping per migration to build a reliable parser.

Is There an API to Bulk Export Charlie Data? [For Engineering]

Yes. Charlie provides a RESTful API (currently at v1 — no v2 has been announced or documented) for programmatic access, but it covers a subset of the data model — primarily team members, salaries, leave, offices, teams, and working data. It is a standard REST API with pagination, not a one-shot bulk dump. (charliehr.com)

How to Generate API Keys

1. Log in as an Admin or Super Admin
2. Expand the Company section in the side navigation
3. Click Integrations
4. Navigate to the API Access tab
5. Follow the instructions to generate your API keys

Charlie only shows the key once — copy the Client ID and Client Secret safely when created. (help.charliehr.com)

Core API Endpoints

Authentication

All requests require an Authorization header built from a Client ID and Client Secret. Based on Charlie's API documentation, the format is: (charliehr.com)

curl -H "Authorization: Token token=YOUR_CLIENT_ID:YOUR_CLIENT_SECRET" \
     https://charliehr.com/api/v1/team_members?page=1&per_page=25

Pagination

The API supports page-based pagination with two query parameters:

• page — the page number (starts at 1)
• per_page — records per page

Many list endpoints cap per_page at 25. The working_weeks endpoint is explicitly unpaginated. Iterate until an empty page is returned or until you reach the total_pages value from the response metadata. (charliehr.com)

Rate Limits

Charlie's official documentation does not specify explicit rate limits. There are no published rate limit headers, documented thresholds, or Retry-After contract in the public API docs. In practice, start conservatively at 1–2 requests per second, implement exponential backoff, and watch for HTTP 429 responses. In testing against a ~100-employee account at 2 requests/second sustained over 15 minutes, no 429 responses were observed — but this is anecdotal and should not be treated as a guaranteed threshold. (charliehr.com)

No Webhook Support — Polling Alternatives

Charlie's API does not natively support webhooks. For near-real-time sync, you must implement polling. Recommended approach:

• Poll /team_members every 15–60 minutes and compare against your local cache using updated_at timestamps (if present in the response) or full-record diffing
• Poll /leave_requests daily with date-range filters to detect new or changed requests
• Store ETags or last-modified timestamps locally to minimize unnecessary full pulls
• For ongoing product integrations, consider a unified API provider (Merge, Apideck) that may abstract polling into webhook-like callbacks on their side

Code Example: Full Team Member Export with Retry Logic

import requests
import time
import json
 
BASE = 'https://charliehr.com/api/v1'
HEADERS = {'Authorization': f'Token token={CLIENT_ID}:{CLIENT_SECRET}'}
 
def get_pages(path, extra=None):
    page = 1
    extra = extra or {}
    retries = 0
    while True:
        params = {'page': page, 'per_page': 25, **extra}
        r = requests.get(
            f'{BASE}{path}',
            headers=HEADERS,
            params=params,
            timeout=30
        )
        if r.status_code in (429, 500, 502, 503, 504):
            retries += 1
            wait = min(60, 2 ** retries)
            print(f"Rate limited or server error on {path} page {page}. "
                  f"Waiting {wait}s (retry {retries})")
            time.sleep(wait)
            continue
        r.raise_for_status()
        retries = 0  # Reset on success
        body = r.json()
        for row in body.get('data', []):
            yield row
        meta = body.get('meta')
        if not meta or page >= meta.get('total_pages', page):
            break
        page += 1
        time.sleep(0.5)  # Conservative pacing — 2 req/sec
 
# Export team members with child objects
team_members = list(get_pages('/team_members'))
print(f"Exported {len(team_members)} team members")
 
for tm in team_members:
    tm_id = tm['id']
    tm['_notes'] = list(get_pages(f'/team_members/{tm_id}/notes'))
    tm['_leave_requests'] = list(get_pages(f'/team_members/{tm_id}/leave_requests'))
    salaries_resp = requests.get(
        f'{BASE}/team_members/{tm_id}/salaries',
        headers=HEADERS,
        timeout=30
    )
    salaries_resp.raise_for_status()
    tm['_salaries'] = salaries_resp.json().get('data', [])
    time.sleep(0.5)
 
# Write to file
with open('charlie_export.json', 'w') as f:
    json.dump(team_members, f, indent=2, default=str)

At 25 records per page, exporting 250 team members takes 10 top-level requests before fan-out to child objects (notes, salaries, leave history, working weeks). The real time cost is the child-object fan-out: 250 members × 3–4 child endpoints = 750–1,000 requests, which at 2 req/sec takes approximately 6–8 minutes.

Three Migration Gotchas from the API

1. Salary history: The Salary Changes CSV report only includes the current salary plus the last active salary. If you need full salary history (common for regulated industries and compensation analytics), you must use GET /team_members/:id/salaries via the API. (help.charliehr.com)
2. Working weeks: Charlie uses working weeks to pro-rate leave. They are a separate object from the team member profile. Preserve them explicitly during migration, or leave balances in the destination system will not reconcile. Charlie does not support irregular working weeks as a first-class model. (help.charliehr.com)
3. API versioning: All endpoints use /api/v1/. No v2 has been announced or documented as of this writing. If you are building a durable integration, pin to v1 and monitor Charlie's changelog for deprecation notices.

What the API Does Not Cover

The API does not expose endpoints for:

• Documents (contracts, payslips, uploaded files)
• Performance reviews
• Engagement polls
• Custom cards
• Onboarding/offboarding checklists
• Handbook content
• Key dates
• Org chart relationships as an independent object (line manager data may be on the team member object, but the chart is not queryable)
• Webhooks — Charlie's API does not natively support webhooks. For real-time sync, you must implement polling (see polling recommendations above).

Does Charlie Export Include Documents and Attachments?

Charlie stores documents directly on team member profiles — contracts, payslips, DBS certificates, policies, and other uploaded files. Standard CSV report exports do not include documents. The only native path to extract documents is the full GDPR account export, which bundles them as files within the downloaded archive. (help.charliehr.com)

There is no API endpoint for bulk-downloading documents. You cannot programmatically iterate over attachments and download them individually through the Charlie API. This is one of Charlie's most significant portability gaps compared to BambooHR (which offers GET /files/{id}), Personio, and HiBob — all of which support document download via their APIs.

For migration work, treat documents as a second stream alongside structured HR records. After extraction, reconcile folders, permissions, and external links. Documents from the GDPR export must be individually re-uploaded to the target system's employee profiles unless you build custom tooling to automate the upload.

What Data Cannot Be Exported from Charlie?

Some data is either unavailable or only available with significant friction. Naming these gaps explicitly is essential for migration planning.

What Format Does Charlie Export Data In?

CSV reports: UTF-8 encoded CSV files. Column headers match the field names selected during report creation. Date formats follow DD/MM/YYYY (UK convention). Country codes use ISO 3166-1 alpha-2 format. (help.charliehr.com)

GDPR full export: XML format. The primary file is company.xml, which contains the bulk of structured data. Documents are organized in subfolders by team member. See the XML sample above for representative structure.

API responses: JSON. Salary records include fields like id, team_member_id, job_title, pay_rate, pay_period, pay_frequency, currency, effective_date, and employment_type. API date parameters use YYYY-MM-DD (ISO 8601), creating an inconsistency with CSV date formats that must be handled during transformation.

Common Data Quality Issues After Export

• Date format mismatches: Charlie uses DD/MM/YYYY in CSVs but YYYY-MM-DD in API responses. Target systems (especially US-based HRIS platforms like BambooHR, Rippling, Gusto) often expect MM/DD/YYYY or ISO 8601. Validate date parsing before import — a date like 03/04/2024 is March 4th in the US but April 3rd in the UK. (help.charliehr.com)
• Salary currency inconsistency: If your org has employees in multiple currencies, verify that the currency field is populated per record, not assumed as GBP based on company settings.
• Line manager references: Exported CSVs reference line managers by name and email. If a manager has left the company and been archived, the reference may point to a non-existent record in the target system. Resolve these dangling references before import.
• Custom card data in XML: Custom card values in the GDPR export use the card name and field labels as defined by the admin who created them. There is no standardized schema across accounts — the XML structure directly mirrors your account's configuration.
• External document links vs. files: Inventory uploaded files separately from external document links. External links (Drive, SharePoint, Dropbox, OneDrive) must be exported from the upstream repository.

Post-Export Validation Checklist

1. Row count matches active + archived employee count in Charlie
2. All salary records have valid ISO 4217 currency codes
3. Date fields parse correctly in your target system's locale — convert DD/MM/YYYY to ISO 8601 (YYYY-MM-DD) immediately after export
4. Documents from GDPR export open and are not corrupted — spot-check at least 10% of files
5. Line manager references resolve to valid employee records (no dangling references to archived/deleted managers)
6. Custom card values are present and correctly mapped to target system custom fields
7. Time off balances reconcile with the current-day snapshot in Charlie's UI
8. Salary history is complete (use API if the CSV report only shows current + last salary)
9. Working week configurations are preserved for leave pro-rating
10. Externally linked documents are accounted for separately from uploaded files

Export for Migration vs. Backup vs. Compliance

Your export strategy changes based on your objective. These three use cases look similar but require different scope, formats, and validation.

Migration to a New HRIS

You need structured, field-mapped data that can be imported into the target platform. Use the API for structured objects, CSV reports for quick reconciliation, and the GDPR XML export for content objects the API does not cover. Budget time for:

• ID mapping: Charlie's internal IDs (format: tm_abc123) will not carry over. Map employee records by email address or employee number.
• Relationship preservation: Line manager hierarchies, team assignments, and office mappings need explicit reconstruction. Rebuild from API fields, not flattened CSV labels.
• Document re-upload: Documents from the GDPR export must be individually re-uploaded to the target system's employee profiles.
• Salary history: Pull via the API if you need more than the current salary plus the last active salary.
• Working weeks: Preserve separately — they drive leave pro-rating logic.

For a deeper look at HRIS migration planning, see our HRIS Data Migration Checklist.

Full Backup

The GDPR export is the closest thing to a full-fidelity backup. Run it before any major change and store the download securely outside Charlie. The export link expires after one week — set a calendar reminder. For structured data redundancy, run CSV reports alongside the GDPR export.

GDPR Compliance and Data Subject Requests

Charlie is designed with UK GDPR compliance in mind. The platform supports Subject Access Requests (SARs) — you can export an individual team member's complete data file from their profile. The GDPR full export satisfies Article 20 data portability requirements at the company level. Charlie stores data on servers in Ireland (within the EEA), holds ISO 27001:2013 and Cyber Essentials certifications, and provides a Data Processing Addendum (DPA). (charliehr.com)

Note that Article 20 does not require Charlie to make its export technically compatible with your destination system — the obligation is to provide data in a structured, commonly used, machine-readable format. Charlie's CSV and XML outputs meet that standard; transformation is your responsibility.

For teams handling cross-border data portability, see our GDPR Compliant Data Migration blueprint.

How Portable Is Charlie Data? [For CTOs]

Data portability rating: Mostly Portable — strong on structured HR data, weak on content objects and developer tooling.

Here is the justification:

• Core employee data (demographics, contact info, salaries, employment history): fully exportable via CSV reports and API. Clean, structured, and ready for transformation.
• Time off data: exportable via CSV reports with current-day balances. Historical request-level detail available via API and GDPR export.
• Documents: exportable only via GDPR export (XML archive with files). No programmatic bulk download. Re-uploading to a target system is manual unless you build custom tooling. This is below the portability baseline set by BambooHR, Personio, and HiBob, all of which offer document download APIs.
• Performance reviews, polls, checklists: locked behind completed-cycle CSV exports and the GDPR XML export. Structured extraction from XML requires custom parsing.
• Workflow configurations, integrations, permissions: not exportable. Must be manually rebuilt.
• Developer tooling gaps: No webhooks, no documented rate limits, 25-record pagination cap, no document API. These gaps increase the engineering cost of any integration or migration project.

Contractually, Charlie's terms state the company does not own client data and will advise the client how to retrieve it on termination — but the client must retrieve it within 30 days. The terms also prohibit benchmarking and competitive monitoring. (charliehr.com)

The real switching cost is moderate for a company under 250 employees (Charlie's sweet spot). Core HR data transfers cleanly. The friction comes from documents, reviews, and any custom card data that needs schema mapping. Charlie does not impose contractual restrictions on data export itself — the GDPR export is available on all plans.

How Long Does a Full Charlie Export Take?

Charlie does not publish export SLAs or row caps for most UI exports. The main hard number in the public docs is the API page size cap of 25 on many endpoints. These estimates are based on hands-on experience with Charlie accounts in the 50–200 employee range, not vendor guarantees. (help.charliehr.com)

Phase breakdown [For PMs]:

1. Scoping (0.5 days): Identify which objects need exporting and in what format. Inventory custom cards, external document links, and review cycles.
2. Access provisioning (< 1 hour): Ensure Super Admin access for GDPR export; generate API keys if needed
3. Extraction (0.5–1 day): Run CSV reports + GDPR export + API calls
4. Transformation (1–3 days): Parse XML, normalize date formats (DD/MM/YYYY → ISO 8601), map fields to target schema, extract and organize documents, resolve dangling line manager references
5. Validation (0.5–1 day): Run the post-export checklist above

Minimum team composition:

• UI exports only: 1 HR admin (no developer needed)
• API export: 1 developer familiar with REST APIs + 1 HR admin for validation
• Full migration: 1 developer + 1 PM + 1 HR admin

Third-Party Tools and Unified APIs for Charlie Export

If you are building a product that needs to read Charlie data (rather than doing a one-time export), unified HRIS APIs can abstract the integration:

• Apideck: Supports CharlieHR as a live connector via their HRIS Unified API. Covers employees and companies. Auth type: API key.
• Merge: Offers a CharlieHR connector supporting Employee, Employment, and Company objects.
• Finch: Lists CharlieHR as an Assisted integration for organization, payroll, and benefits data.
• Bindbee: Normalizes CharlieHR data into unified models across 65+ HRIS platforms.

These tools are designed for ongoing product integrations, not one-time migration exports. For a one-time full extraction, the native methods (GDPR export + CSV reports + direct API) are faster and more complete.

When to Bring in Help

For a straightforward export of a sub-250-employee Charlie account, most HR teams can self-serve with the GDPR export and CSV reports. The complexity rises when you need to:

• Parse and transform XML into importable formats for a target HRIS (budget 1–3 days of developer time for schema mapping alone)
• Preserve document-to-employee associations across platforms (the GDPR export bundles files in folders, but folder-to-employee mapping requires parsing company.xml)
• Map custom card schemas that do not exist in the destination system
• Reconcile time off balances with historical accuracy across different leave-year configurations
• Pull full salary history via the API when CSV reports are incomplete
• Meet compliance timelines for GDPR data portability requests (Article 20 mandates response within 30 days)
• Handle external document links alongside Charlie-hosted files