How People Use ChatGPT

TL;DR

Until now, almost everything we “knew” about chatbot usage came from self-report surveys (biased) or from one competitor’s much smaller user base (Anthropic’s Claude). This paper is the first to look at consumer ChatGPT from inside OpenAI: 700M weekly users, ~2.6B messages/day by mid-2025. The clever part isn’t a model — it’s a measurement pipeline: strip PII, then have gpt-5-mini classify each message along several taxonomies (work vs. not, topic, intent, O*NET job activity, satisfaction) so that no human ever reads a message. The findings reframe the AI-and-the-economy debate: non-work use is growing faster than work use (now ~70%); the top three topics — Practical Guidance, Seeking Information, Writing — are ~78% of all use; and the dominant value is decision support (“Asking”), not task automation (“Doing”). Coding is only 4.2% of ChatGPT messages and “companionship” is ~1.9% — both far below the hype.

Problem & Motivation

The pain is simple and concrete: a technology adopted by 10% of the planet’s adults in under three years, and nobody outside the labs had real data on what people do with it. Every economic model of “AI’s impact on work” was being built on guesses.

Why prior approaches fell short:

• Surveys self-report. People misremember and mis-state their usage (the paper cites Ling & Imas 2025 on self-report bias). You ask “do you use AI for work?” and get a vibe, not a log.
• Existing log studies were narrow. Anthropic’s Clio study (Handa et al. 2025) looked at Claude — a developer-skewed audience — and concluded ~33% of work conversations were coding. Extrapolating that to “how humanity uses chatbots” is like measuring car usage by surveying a Formula 1 paddock.
• You can’t just read the messages. The obvious study — read a sample of conversations and label them — is a privacy catastrophe and legally radioactive. That constraint is why this had never been done at scale.

So the real problem is two-headed: (1) get representative data, which only OpenAI can; and (2) analyze intimate text without any human seeing it. The paper’s contribution is solving #2 well enough that #1 becomes publishable.

What’s New (Core Contribution)

This is an empirical / measurement paper, not a new algorithm. The novelty is in the apparatus and the facts it produces.

1. A privacy-preserving, fully-automated classification pipeline. Before: researchers read transcripts (or used coarse metadata). Now: messages are PII-scrubbed by an internal “Privacy Filter” LLM, then labeled by classifier LLMs over a controlled label space, with technical frictions (interfaces that literally don’t render message text to researchers). The output a human sees is a category, never the text. This is the reusable, sellable idea.

2. New taxonomies for intent, not just topic. Before: studies classified what a conversation is about (topic) or which occupation it maps to. Now: the Asking / Doing / Expressing rubric classifies what kind of output the user wants — information to make a decision (Asking), a produced artifact (Doing), or pure expression (Expressing). This is the conceptual contribution that lets them argue ChatGPT’s value is decision support, not just automation.

3. Representative-scale facts with demographic + occupational linkage. They link a 130k-user subsample to aggregated employment/education data — but only inside a Data Clean Room where every query needs 6-coauthor sign-off + vendor approval and a 100-user minimum aggregation threshold. Before: no log study tied usage to real occupation/education. Now: “educated users in high-paid professional jobs use it for work and for Asking.”

4. Eight documented facts that correct prevailing narratives — coding is small (4.2%), companionship is tiny (1.9%), the gender gap closed, non-work dominates and is growing.

What’s not new: the classifiers themselves are vanilla LLM-prompt classifiers; the O*NET mapping follows Tomlinson et al. (2025); validating against the public WildChat dataset follows Eloundou et al. The genuine novelty is the scale + representativeness + privacy architecture, plus the Asking/Doing/Expressing lens.

How It Works (Technically)

The “mechanism” here is a data pipeline, so let’s trace one message through it end to end, then look at the classifiers and the math you need to trust the numbers.

Architecture & data flow

flowchart TB
  subgraph SAMPLE[Sampling layer]
    A[All consumer messages<br/>Free/Plus/Pro] --> B[Uniform sample<br/>~1.1M conversations]
    B --> C[Pick 1 message per conversation<br/>+ prior 10 messages as context]
    C --> D{Exclusion filters}
    D -->|drop opt-outs, under-18,<br/>deleted, banned, logged-out| E[Eligible message set]
  end
  subgraph PRIVACY[Privacy layer - no human reads text]
    E --> F[Privacy Filter LLM<br/>strips PII]
    F --> G[Truncate to 5000 chars]
  end
  subgraph CLASSIFY[Classification layer]
    G --> H1[Work vs Non-work<br/>gpt-5-mini]
    G --> H2[Topic: 24 to 7 groups<br/>gpt-5-mini]
    G --> H3[Intent: Ask/Do/Express<br/>gpt-5-mini]
    G --> H4[O*NET IWA: 333 labels<br/>gpt-5-mini]
    G --> H5[Interaction Quality<br/>gpt-5]
  end
  H1 & H2 & H3 & H4 & H5 --> I[(Aggregated counts only<br/>humans see these)]
  I --> J[Reweight by daily volume]
  J --> K[Figures and the eight facts]
  L[(Employment data<br/>130k users)] -.->|Data Clean Room<br/>100-user min, approval-gated| I

Schematic of one message moving through the pipeline. Click "Step" to advance: raw message → PII scrubbed → fanned out to five classifiers → collapsed to category counts. Notice the "human visibility" line — humans only ever touch the right-most aggregate box.

Step 1 — Sampling. They draw ~1.1M conversations uniformly, then take one message per conversation (so heavy users don’t dominate the topic distribution) plus the prior 10 messages as context (so “10 more” can be understood). A second, user-level sample caps at 6 messages/user. Crucially, the underlying table is itself sampled at a rate that changed over time, so they apply sampling weights to keep a fixed ratio to true message volume — without this, months with higher sampling rates would look artificially busy.

Step 2 — Privacy filter. An internal LLM scrubs PII. This is the linchpin: every downstream step operates on de-identified text, and humans see only labels.

Step 3 — The classifiers. Each taxonomy is just a prompt defining a label set, applied by gpt-5-mini (and gpt-5 for the harder Quality task). The five taxonomies:

A subtle, smart design choice: the Quality classifier infers satisfaction from the user’s subsequent message (“perfect, thanks” vs. “no, that’s wrong”) rather than asking the model to judge its own output — using human behavior as the label, not model self-assessment.

Step 4 — The math you actually need. There’s almost no scary math; the rigor is in measurement, so demystify the three things that matter:

• Reweighting. Each sampled message $m$ gets a weight $w_m$ so that the weighted sample reproduces true population shares. A topic’s reported share is $\text{share}(t) = \frac{\sum_{m \in t} w_m}{\sum_m w_m}$ — a weighted average, not a raw count. Plain English: a message from an under-sampled day counts for more so the totals match reality.
• Intent as a measure of unobserved truth. They never see ground-truth intent (it’s in the user’s head). They argue the classifier output ≈ “the best guess a human would make from the same prompt,” validated because (a) LLM labels correlate highly with human labels on WildChat, and (b) results are stable when you add an “uncertain” option. This is the load-bearing assumption — treat it as “well-calibrated guesses,” not truth.
• Validation against WildChat. They run the same prompts over a public conversation dataset that was human-labeled, and report agreement (Appendix B). This is the only place external readers can check the classifiers, since the real data is private.

Step 5 — The clean room. Linking usage to occupation/education never touches user rows. Queries run inside a Data Clean Room: a 6-coauthor committee signs off, the data vendor approves the notebook, and any output cell with <100 users is suppressed or coarsened (99 anesthesiologists become “medical professionals”). This is differential-privacy-flavored discipline enforced procedurally rather than mathematically.

The algorithm, simplified

The “algorithm” is the classification loop. The contribution is the guardrails, so they’re spelled out, not stubbed:

def classify_corpus(conversations, taxonomies):
    # taxonomies: dict[name -> (prompt_text, model_id)]  e.g. INTENT -> (ask_do_express_prompt, "gpt-5-mini")
    results = []
    for convo in sample_one_per_conversation(conversations):   # de-dupe heavy users
        if excluded(convo):                                    # opt-out / under-18 / deleted / banned / logged-out
            continue
        target = convo.last_user_message
        context = convo.prior_messages[-10:]                   # so "10 more" is interpretable

        # ---- privacy boundary: nothing past here is ever shown to a human ----
        text = privacy_filter(target, context)[:5000]          # strip PII, cap length to stabilize labels

        labels = {}
        for name, (prompt, model) in taxonomies.items():
            # classifier = LLM constrained to a fixed label set; intent is the user's GOAL, not the words
            labels[name] = llm(prompt, text, model=model, allowed_labels=taxonomy_labels[name])

        results.append({"weight": sampling_weight(convo), **labels})  # store category + weight, never text

    # humans only ever touch weighted AGGREGATES below this line
    return weighted_shares(results)        # share(t) = sum(w for m in t) / sum(w)

The whole paper hangs on two lines: the privacy_filter(...)[:5000] boundary, and storing labels/weight but never text.

Built on Prior Work

Results & Evidence

What they tested: ~1.1M conversations (May 2024–Jul 2025) for topic/intent/O*NET; a 130k-user subsample for demographics/employment; full population counts for growth.

The eight headline facts:

1. Non-work dominates and is pulling away. Work-related share fell from 47%→27% (Jun 2024→Jun 2025); non-work is now ~70%+. Driven by within-cohort behavior change, not just new users.
2. Three topics ≈ 78% of everything: Practical Guidance (~29%, flat), Seeking Information (14%→24%, growing), Writing (36%→24%, shrinking as a share but still huge).
3. Writing dominates work: ~40% of work messages; ~two-thirds of Writing is modifying user-provided text (edit/translate/summarize), not generating from scratch.
4. Intent split ≈ 49% Asking / 40% Doing / 11% Expressing, with Asking growing faster and rated higher quality. At work, Doing rises to ~56%.
5. Gender gap closed: ~80% masculine-named active users early on → ~48% by Jun 2025.
6. Young-skewed: ~half of adult messages from users under 26.
7. Fast growth in low/middle-income countries.
8. Education/occupation gradient: highly-educated professionals use it more for work and more for Asking.

Two narrative-correcting numbers: coding = 4.2% (vs 33% on Claude) and companionship/relationships = 1.9% (vs claims that “therapy/companionship” is the top use case).

What the evidence does NOT establish — read this before quoting the paper to a client:

• Intent/topic are LLM guesses, not ground truth. Validation is against WildChat (a different chatbot’s users) and the proprietary corpus is unauditable externally. The numbers are as good as the classifiers, and you can’t independently check them.
• No causal claims about productivity or welfare. “Decision support creates value” is an interpretation layered onto usage shares, leaning on Collis & Brynjolfsson’s $97B surplus estimate — not measured here.
• Consumer plans only. Enterprise/Team/Edu excluded, and API usage excluded — which is exactly where heavy coding lives. So “coding is small” means “small in the consumer chat UI,” not “small overall.” The paper says as much (Codex/API coding grew elsewhere). Don’t let a client over-read this.
• Single vendor, single period, observational. No counterfactual, no other chatbot in-sample, snapshot of a fast-moving target.
• Name-based gender and self-reported age are noisy proxies.

The evidence is strong on description at scale and weak (by design) on causation and external verifiability.

How You’d Use It

Two distinct payoffs for an AI services company: the findings (strategy) and the method (a buildable, sellable capability).

Use the findings to position offerings:

• Sell “decision support,” not “automation.” The single most useful result is Asking > Doing and Asking is rated higher quality. Clients keep asking for agents that do tasks; the data says users get more value from systems that advise. Pitch co-pilot/advisor workflows (research assistant, options-with-tradeoffs, “help me decide”) as a higher-satisfaction, lower-risk product than full automation.
• Writing-as-editing is the killer app. Two-thirds of Writing is modifying user text. Build editing/critique/translation/summarization tooling over the client’s own documents rather than blank-page generation — that’s where real demand is.
• Reset the coding narrative for non-dev clients. When a client assumes “everyone uses AI to code,” you can correctly say coding is a small slice of chat usage and lives in the API/agent layer — which is precisely the bespoke work you’d sell them.

Use the method as a capability you can offer: Most mid-size companies are sitting on support tickets, sales call transcripts, and internal chat logs they’re afraid to analyze for privacy reasons. This paper is a blueprint for a “privacy-preserving conversation analytics” offering: PII-scrub → LLM-classify against a client-defined taxonomy → report only aggregates, with a clean-room-style approval gate. That’s a concrete, defensible service (and a compliance story your competitors won’t have).

Build Your Own (Minimal Recipe)

You can stand up an 80%-of-the-value version of the pipeline in a day or two. The science here is operational discipline, not exotic ML.

Components, in build order:

1. A taxonomy + prompt per dimension. Start with one (e.g., your own “Asking/Doing/Expressing” or topic buckets). The label space must be closed — force the model to pick from a fixed list, including an Ambiguous/Uncertain option.
2. A PII scrubber. Microsoft Presidio for deterministic redaction, optionally backed by an LLM pass for stragglers. This is the privacy boundary — make it the first thing every message hits.
3. A constrained classifier call. Cheap model (a mini/haiku-class model), temperature 0, structured output / function-calling to force a label from the allowed set. Include the prior N turns as context.
4. A validation set. Hand-label ~200–500 examples (or use WildChat), measure agreement (accuracy / Cohen’s κ). Iterate the prompt until agreement is acceptable. Skip this and your numbers are fiction.
5. Aggregate-only output + reweighting. Store labels + weights, never raw text in the analyst-facing layer. Apply sampling weights if your sampling rate varies. Suppress small cells.

The 1–2 genuinely hard parts:

• Validation and prompt stability. “Intent” is fuzzy; getting a classifier that agrees with humans and stays stable across phrasing and context length (note the 5,000-char truncation — long context degraded their labels) is the real work.
• The privacy architecture as a process, not a checkbox. The clean room’s power is procedural: approval gates, suppression thresholds, interfaces that don’t render text. Replicating the discipline (so a curious analyst can’t peek) is harder than the code.

Reach for: any cheap instruct model with structured outputs; Presidio for PII; a sampling/weighting script in pandas/polars; scikit-learn for κ/agreement metrics. No fine-tuning, no RL, no vector DB required.

How to Improve It

Limitations are your roadmap — here are five concrete, testable extensions:

1. Close the API/consumer gap. The biggest blind spot is excluding API + agent traffic, which hides coding. Build a unified pipeline spanning chat UI and programmatic usage to get a true picture of where coding/automation actually happens. Testable: re-run the topic classifier on API logs and compare the 4.2% figure.
2. Multi-label + confidence, not single-label. Real messages do several things at once. Emit a distribution over labels with calibrated confidence; report results both ways and check whether the “Asking vs Doing” story survives. Cheap to test against the existing WildChat labels.
3. Cross-classifier validation with a second model family. All classifiers are GPT-family — shared blind spots. Re-label a slice with a non-OpenAI model (Claude/Llama) and report inter-model agreement as an honesty metric. This is exactly the verification a buyer of your analytics service should demand.
4. Conversation-level, not message-level, intent. Sampling one message per conversation throws away the arc (Ask → then Do). Model the trajectory (e.g., a small state machine over turn-level labels) to capture how sessions evolve — likely changes the Asking/Doing ratio.
5. Outcome linkage, ethically. They measure satisfaction via the next message; pair the consented subsample with opt-in outcome surveys (“did this help you decide?”) to move from usage to value, turning a descriptive study into a (weakly) causal one.

Glossary

• Classifier (LLM-based) — an LLM given a prompt that forces it to assign input to one of a fixed set of labels; here, the core measurement instrument.
• Taxonomy — the fixed label set a classifier picks from (e.g., the 7 topic groups).
• PII scrubbing / Privacy Filter — automated removal of personally identifying information before any analysis; the privacy boundary.
• Data Clean Room (DCR) — a controlled environment where two parties’ data can be jointly queried but neither side sees the other’s raw rows; outputs are aggregate-only and approval-gated.
• Suppression threshold — a rule (here, <100 users) that hides or coarsens any result cell too small to be anonymous.
• Reweighting / sampling weights — multipliers that make a non-uniform sample reproduce true population proportions.
• O*NET — U.S. Dept. of Labor database classifying jobs into work activities (GWA → IWA → DWA, from general to detailed).
• GWA / IWA — Generalized (41) vs Intermediate (332) Work Activities; the granularity levels used to map messages to job tasks.
• Asking / Doing / Expressing — the paper’s intent rubric: want information for a decision / want a produced artifact / pure expression.
• WildChat — a public, consented dataset of human-chatbot conversations used to validate the classifiers against human labels.
• WAU — Weekly Active Users; the headline adoption metric (~700M by Jul 2025).
• Within-cohort change — behavior shifting among the same users over time, vs. shifts caused by new users joining (composition).
• Pre-training vs post-training — first stage learns next-token prediction over a huge corpus (a world representation); second stage (fine-tuning + RL from human/automated feedback) shapes it into a helpful assistant.
• Consumer surplus — the value users get above what they pay; cited (~$97B/yr) to argue welfare gains, not measured in this paper.