How to Download All Raw Data from Mixpanel

Mixpanel tracks everything — every click, every session, every funnel drop-off. But the real power isn’t just watching dashboards. It’s owning the raw data so you can slice it, pipe it, and act on it anywhere you want.

Whether you need raw events for a data warehouse, a compliance audit, or a custom attribution model, this guide covers every method available to get your data out of Mixpanel cleanly and completely.

Let’s get into it.

Why Exporting Raw Data from Mixpanel Matters

Mixpanel is an event-based analytics platform trusted by over 30,000 companies worldwide, from early-stage startups to enterprises. According to Mixpanel’s own benchmarks, teams that connect product analytics to external workflows see up to 3× faster decision-making compared to those relying solely on in-app dashboards.

The problem? Dashboards are read-only views. You can see what happened, but the moment you want to:

• Feed events into a data warehouse like Snowflake or BigQuery
• Build a custom ML model on top of behavioral data
• Run cohort analysis in a BI tool like Tableau or Looker
• Fulfill a GDPR data subject request requiring a full event log
• Create cross-platform attribution models beyond what Mixpanel natively supports

…you need the raw underlying data.

Research from Gartner shows that 87% of companies say data is their most underutilized business asset. Exporting your Mixpanel events is the first step toward actually leveraging what you’ve already collected.

What “Raw Data” Means in Mixpanel

Before exporting, it helps to understand exactly what raw data looks like in Mixpanel.

Every user action you track creates an event — a JSON object with:

• Event name (e.g., “Sign Up”, “Purchase”, “Button Clicked”)
• Distinct ID — the anonymized user identifier
• Timestamp — when the event occurred (UTC)
• Properties — a dictionary of custom attributes like plan_type, country, device, referrer, and anything else you pass at tracking time

A raw export gives you these event records in full fidelity — not aggregated, not sampled, not summarized. Just the individual rows.

Mixpanel processes billions of events per day across its platform. When you export, you can pull anywhere from a single day’s worth to your entire historical dataset going back years.

Method One — Using the Mixpanel UI to Export Data as CSV

This is the fastest option for ad hoc exports. No API setup required.

What you can export this way:

• Event data filtered by date range and event type
• User profiles
• Report results (funnels, retention, flows)

Steps to export from the Mixpanel interface:

Events Report Export

Go to Reports → Events in your Mixpanel project. Apply any filters you want — date range, event name, user properties. Once the data is loaded, click the Export button in the top-right corner and choose CSV or JSON.

Funnel Export

Navigate to your funnel report. After configuring your steps, click the three-dot menu (⋯) on the report and select Export CSV. This gives you the conversion rates and user-level data for each step.

Retention Export

Open any retention report, click the download icon or three-dot menu, and select Export. You get cohort sizes and retention percentages by time window.

User Profiles Export

Go to Users → Explore, apply your filters, then click the Export button. You can download up to 1,000 profiles per export from the UI. For larger datasets, you’ll need the API.

Limitation to know: CSV exports from the UI are capped and don’t give you the raw event stream in bulk. For full historical exports, you need the Data Export API or Mixpanel’s pipeline integrations.

Method Two — Mixpanel Data Export API

This is the most flexible and powerful method for exporting raw event data at scale.

What the Data Export API Does

The Data Export API gives you access to the raw event stream — every individual event record, in full JSON, for any date range you specify.

According to Mixpanel’s documentation, the API returns data in NDJSON format (newline-delimited JSON), where each line is a complete event object. A typical response looks like:

{“event”: “Sign Up”, “properties”: {“distinct_id”: “abc123”, “time”: 1700000000, “country”: “US”, “plan”: “pro”}}

{“event”: “Purchase”, “properties”: {“distinct_id”: “abc123”, “time”: 1700003600, “revenue”: 99}}

Authentication

Mixpanel uses Basic Auth for the Data Export API. You authenticate with your Service Account credentials — a username and secret you generate in your Project Settings under Service Accounts.

curl –request GET \

  –url ‘https://data.mixpanel.com/api/2.0/export’ \

  –user ‘YOUR_SERVICE_ACCOUNT_USERNAME:YOUR_SERVICE_ACCOUNT_SECRET’

Core Export Parameters

Full Export Example

To export all events for a 7-day window:

curl –request GET \

  –url ‘https://data.mixpanel.com/api/2.0/export?from_date=2024-01-01&to_date=2024-01-07’ \

  –user ‘serviceaccount@project.mixpanel.com:YOUR_SECRET’ \

  –output raw_events.ndjson

Exporting a Specific Event

To pull only Purchase events:

curl –request GET \

  –url ‘https://data.mixpanel.com/api/2.0/export?from_date=2024-01-01&to_date=2024-01-31&event=%5B%22Purchase%22%5D’ \

  –user ‘serviceaccount@project.mixpanel.com:YOUR_SECRET’ \

  –output purchases.ndjson

(%5B%22Purchase%22%5D is the URL-encoded form of [“Purchase”])

Rate Limits to Know

Mixpanel applies rate limiting to Data Export API calls. As of the latest documentation:

• Concurrent requests: Up to 3 simultaneous requests per project
• Date range per request: Requests covering large ranges (90+ days) may take several minutes
• Data lag: Raw data in the export API reflects events typically within 1–2 hours of ingestion

For massive historical exports (years of data), break your requests into monthly chunks and paginate sequentially to avoid timeouts.

Python Script for Bulk Export

import requests

import json

from datetime import datetime, timedelta

USERNAME = “serviceaccount@yourproject.mixpanel.com”

SECRET   = “your_secret_here”

START    = “2023-01-01”

END      = “2024-01-01”

url = “https://data.mixpanel.com/api/2.0/export”

params = {“from_date”: START, “to_date”: END}

response = requests.get(url, params=params, auth=(USERNAME, SECRET), stream=True)

with open(“all_events.ndjson”, “w”) as f:

    for line in response.iter_lines():

        if line:

            f.write(line.decode(“utf-8”) + “\n”)

print(“Export complete.”)

Method Three — Mixpanel Warehouse Connectors (Native Pipeline)

For teams already using a modern data stack, Mixpanel’s Warehouse Connectors (also called Schematized Export or Pipeline Export) are the cleanest way to continuously sync raw events to your warehouse.

Supported Destinations

Mixpanel natively supports syncing to:

• Google BigQuery
• Amazon S3
• Amazon Redshift (via S3)
• Snowflake (via S3)
• Azure Blob Storage

This feature is available on Growth and Enterprise plans. According to Mixpanel, teams using automated pipeline exports reduce time-to-insight by up to 60% compared to manual API pulls.

Setting Up S3 Export

Step 1 — Create an S3 Bucket

In AWS, create a new S3 bucket in the region closest to your team. Apply a bucket policy that gives Mixpanel’s export service write access:

{

  “Version”: “2012-10-17”,

  “Statement”: [

    {

      “Sid”: “MixpanelWrite”,

      “Effect”: “Allow”,

      “Principal”: { “AWS”: “arn:aws:iam::485438090326:root” },

      “Action”: [“s3:PutObject”, “s3:GetBucketLocation”],

      “Resource”: [

        “arn:aws:s3:::your-bucket-name”,

        “arn:aws:s3:::your-bucket-name/*”

      ]

    }

  ]

}

Step 2 — Configure in Mixpanel

Go to Project Settings → Pipeline Export → Add Pipeline. Select Amazon S3 as the destination. Enter your bucket name and region, then choose the data tables to export: Events, People, or both.

Step 3 — Set the Export Schedule

Choose Daily (recommended) or Hourly exports depending on your latency requirements. Mixpanel will begin populating your bucket with compressed NDJSON files partitioned by date.

Setting Up BigQuery Export

Step 1 — Grant Access

In Google Cloud Console, grant the Mixpanel service account (export@mixpanel-prod.iam.gserviceaccount.com) the BigQuery Data Editor and BigQuery Job User roles on your project.

Step 2 — Configure in Mixpanel

Go to Project Settings → Pipeline Export → Add Pipeline → Google BigQuery. Enter your GCP Project ID and the target dataset name. Mixpanel will create and manage the schema automatically.

Step 3 — Verify Schema

Once active, Mixpanel creates event tables in your BigQuery dataset with the following structure:

Mixpanel processes data volumes that make automated pipelines critical at scale — enterprise Mixpanel customers commonly export tens of billions of rows annually into their warehouses.

Method Four — Exporting User Profiles (People Data)

User profile exports are separate from event exports. Each profile represents a user with their current property values (not a historical event log).

Via the API

Use the Engage API endpoint:

curl –request POST \

  –url ‘https://mixpanel.com/api/2.0/engage’ \

  –user ‘YOUR_SERVICE_ACCOUNT:YOUR_SECRET’ \

  –header ‘Content-Type: application/x-www-form-urlencoded’ \

  –data ‘output_properties=[“$email”,”$name”,”$country_code”,”plan”]&page_size=1000’

The response includes:

{

  “results”: [

    {

      “$distinct_id”: “abc123”,

      “$properties”: {

        “$email”: “user@example.com”,

        “$name”: “Jane Smith”,

        “plan”: “pro”

      }

    }

  ],

  “session_id”: “abc-session”,

  “page”: 0,

  “total”: 15000

}

Paginate through results using the session_id and incrementing page parameter until you’ve retrieved all profiles.

Paginating Large Profile Exports

import requests

USERNAME = “serviceaccount@yourproject.mixpanel.com”

SECRET   = “your_secret”

BASE_URL = “https://mixpanel.com/api/2.0/engage”

session_id = None

page = 0

all_profiles = []

while True:

    params = {“page_size”: 1000, “page”: page}

    if session_id:

        params[“session_id”] = session_id

    r = requests.post(BASE_URL, data=params, auth=(USERNAME, SECRET))

    data = r.json()

    profiles = data.get(“results”, [])

    all_profiles.extend(profiles)

    session_id = data.get(“session_id”)

    total = data.get(“total”, 0)

    print(f”Fetched {len(all_profiles)} / {total}”)

    if len(all_profiles) >= total:

        break

    page += 1

print(f”Total profiles exported: {len(all_profiles)}”)

Method Five — Using the Query API for Aggregated Exports

If you don’t need raw row-level data but want to export the results of Mixpanel reports programmatically, the Query API (also called the JQL API or Insights API) lets you pull aggregated metrics directly.

This is useful for scheduled reporting pipelines where you want daily/weekly summaries pushed to a spreadsheet or dashboard without manual downloads.

Example — Export Funnel Data via API

curl –request GET \

  –url ‘https://mixpanel.com/api/2.0/funnels?funnel_id=YOUR_FUNNEL_ID&from_date=2024-01-01&to_date=2024-01-31&unit=day’ \

  –user ‘YOUR_SERVICE_ACCOUNT:YOUR_SECRET’

The response returns conversion rates, entry counts, and step-by-step drop-off data for every day in the range — ready to be stored or visualized in any BI tool.

Method Six — Lexicon and Schema Export

Teams managing large event schemas often need to export their Lexicon — Mixpanel’s event and property registry — to document what’s being tracked and maintain data governance standards.

Export the Lexicon via API

curl –request GET \

  –url ‘https://mixpanel.com/api/app/projects/YOUR_PROJECT_ID/schemas/event’ \

  –header ‘Authorization: Bearer YOUR_SERVICE_ACCOUNT_TOKEN’

The response gives you every event name, its status (active/hidden/dropped), and all associated property definitions. This is especially valuable for engineering teams onboarding new analysts or auditing tracking coverage.

According to a 2023 survey by the Analytics Engineering community, teams with documented event schemas resolve data quality issues 45% faster than those relying on undocumented tracking plans.

How to Handle Large-Scale Historical Exports

Pulling a week of data is easy. Pulling three years of data at scale requires a strategy.

Break requests into monthly windows. The Data Export API handles individual requests best when they span 30 days or less. For a multi-year export, loop through each calendar month.

Run exports during off-peak hours. API rate limits are shared across your project. Scheduling large exports for early morning (UTC) reduces contention with live dashboard traffic.

Use compression. Mixpanel’s raw exports can be large — a single day of events for an active product can generate 500MB–5GB+ of NDJSON. If you’re writing to S3 or a local disk, enable gzip compression in your pipeline.

Deduplicate with insert_id. Mixpanel uses insert_id as a deduplication key. If you re-run an export for an overlapping date range, use this field to prevent duplicate records in your destination.

Monitor for data lag. Mixpanel notes that some events, particularly those from mobile SDKs with offline buffering, may arrive hours or even days late. For compliance or billing-critical exports, always re-export the last 3–7 days as part of your pipeline.

Common Errors and How to Fix Them

401 Unauthorized Your service account credentials are wrong or the account doesn’t have access to the project. Regenerate the secret in Project Settings → Service Accounts.

400 Bad Request — Invalid Date Dates must be formatted exactly as YYYY-MM-DD. Passing a Unix timestamp or a different format will fail.

Empty Response No events exist for the specified date range and filters. Double-check that the from_date/to_date range covers active tracking periods.

Request Timeout Your date range is too wide. Break the request into smaller windows (7–30 days) and retry.

403 Forbidden — Pipeline Not Enabled Schematized export (warehouse connectors) requires a Growth or Enterprise plan. Upgrade your plan or use the Data Export API instead.

Mixpanel Data Export vs. Warehouse Connectors — Which to Use

Bottom line: Use the API for targeted, on-demand, or script-based pulls. Use Warehouse Connectors when you need a production-grade, automated data pipeline running continuously.

Key Statistics at a Glance

• Mixpanel is used by 30,000+ companies worldwide across product, engineering, and marketing teams
• Teams with automated data pipelines reach insights up to 60% faster than those relying on manual exports
• 87% of companies say data remains their most underutilized business asset (Gartner)
• Documented event schemas help teams resolve data quality issues 45% faster
• Mobile SDK buffering means up to 5–10% of events may arrive with a delay of several hours to days
• Enterprise customers commonly process tens of billions of rows annually through Mixpanel’s pipeline export
• A single day of events for an active product can generate 500MB–5GB+ in raw NDJSON format
• The Data Export API supports up to 3 concurrent requests per project
•  

Conclusion

Getting raw data out of Mixpanel is straightforward once you know which method fits your situation.

For quick one-off pulls, the UI CSV export gets you there in minutes. For programmatic access to the full event stream, the Data Export API is your go-to. For teams running a modern data stack with a warehouse, Warehouse Connectors give you a continuous, production-grade pipeline with zero manual maintenance.

The real leverage comes when you connect that exported data to the rest of your workflows — attribution models, customer segmentation, and outbound targeting. Behavioral data tells you who’s engaging, how deeply, and where they drop off. That’s powerful signal for any go-to-market motion.

If you’re at the stage where you’re not just analyzing data but acting on it — reaching the right people at the right time with the right message — that’s exactly what SalesSo is built for. We run full outbound lead generation across LinkedIn, cold email, and cold calling: targeting, campaign design, and scaling, all done for you.

Book a strategy meeting and see what a systematic outbound pipeline looks like for your business.