You can migrate useful context from ChatGPT to Claude, but the reliable approach is a reviewed reconstruction rather than a one-click account conversion. Anthropic provides an experimental memory-import flow for context text. The documented workflow does not automatically rebuild your complete ChatGPT history, prompt library, files, Projects, or custom GPT behavior.
The practical sequence is to preserve your ChatGPT data, classify what is worth moving, place each item in the correct Claude feature, and test recurring tasks. A preference such as “use concise bullet points” may belong in account-wide instructions. Client terminology and approved documents usually belong in that client’s Claude Project. A connected action requires a separate capability and permission check.
This guide covers a user-interface migration process with review gates. It does not claim a direct ChatGPT-to-Claude API, lossless history transfer, or automatic custom GPT conversion.
A successful migration is a tested reconstruction of useful behavior, not a memory dump.
Sort context by what it is before moving it
Use this four-layer migration contract as an editorial organizing framework, not as a vendor-defined schema:
- Preferences: tone, verbosity, formatting, language, and accessibility requirements.
- Operating rules: required checks, citation expectations, prohibited behavior, escalation conditions, and output structure.
- Project context: goals, terminology, stakeholders, current status, and approved reference material.
- Reusable assets: prompts, examples, files, test cases, Skills, and tool dependencies.
Choose a destination by scope and function. Claude distinguishes account-wide instructions, Project instructions and knowledge, and Skills. Projects are scoped workspaces with their own instructions and knowledge base. Information is not automatically shared across unrelated Projects or chats. See Anthropic’s guides to Claude personalization features and Projects and project knowledge.
| Asset | Candidate destination | Transfer approach | Acceptance check |
|---|---|---|---|
| Durable preferences | Claude account instructions or memory | Rewrite as observable rules, such as “use bullets and stay under 200 words.” | Run a representative task and check format and length. |
| Operating rules | Account instructions or a Project | Keep general rules global; move client or workstream rules to the relevant Project. | Check scope conflicts and test each location separately. |
| Project files | Claude Project knowledge | Review, redact, and upload only material needed for that workstream. | Ask for a fact that requires retrieving the intended file. |
| Prompt templates | Prompt library or suitable Claude Skill | Keep intended inputs, example output, version, and failure conditions with the prompt. | Run a representative input and validate the output structure. |
| Custom GPT dependencies | Project, Skill, or separately verified tool | Inventory instructions, knowledge, capabilities, apps, and actions before rebuilding. | Test retrieval, structured output, permissions, and each action independently. |
Build a reviewed migration package
Start with a recoverable source copy. In ChatGPT, use the current Settings > Data controls > Export flow, or OpenAI’s Privacy Portal route where applicable. Business, Enterprise, and other managed workspaces may require the workspace owner to handle the export. Interface labels, account eligibility, and organization controls can change.
Keep the original export unchanged. Make a separate working copy and inspect the downloaded archive rather than assuming a universal filename or structure. OpenAI documents the export process, but the reviewed documentation does not guarantee that every archive contains a particular file such as conversations.json. The export is a backup and extraction source, not a direct Claude import.
Collect distinct records for custom instructions, saved memories, selected conversation corrections, prompt templates, relevant GPT configuration, and reference files. ChatGPT memory is not a complete transcript. OpenAI says it does not retain every detail from every conversation, and information derived from chat history can change over time. Read the current ChatGPT memory FAQ and custom-instructions guide when deciding what needs separate preservation.
Before promoting any extracted preference, check whether it is current, accurate, contradictory, or sensitive. Remove information that is unnecessary for the target task, especially personal, client, health, financial, legal, or proprietary details. An AI-generated memory summary is a set of candidates for review, not a complete account record.
For a small migration register, use separate rows for separate source items, files, and test runs. The following is an illustrative implementation schema, not a vendor export format:
{
"record_type": "instruction_candidate",
"source_platform": "ChatGPT",
"source_account_or_workspace": "illustrative-workspace",
"source_conversation_id": "illustrative-conversation-42",
"source_message_id": "illustrative-message-117",
"source_file_id": null,
"import_run_id": "run-2026-11-08-001",
"target_scope": "project",
"target_location": "client-content-project",
"sensitivity_class": "reviewed-redacted",
"review_status": "approved",
"reviewed_by": "context-owner",
"extracted_at": "2026-11-08",
"last_verified_at": "2026-11-08",
"unique_key": "ChatGPT|illustrative-workspace|illustrative-conversation-42|illustrative-message-117|run-2026-11-08-001"
}The fields above preserve the row grain: one source observation or candidate instruction per record. A source file, prompt version, approved canonical rule, and test result should have their own record types and identifiers. If several conversations support one final rule, retain each provenance record and link them to the canonical rule rather than overwriting the evidence.
Import memory and place instructions in the right Claude scope
Anthropic’s documented memory-import process is a copy-and-paste workflow. Open Claude’s memory import from its current memory settings, copy Anthropic’s supplied extraction prompt, paste it into ChatGPT or another supported AI service, review the generated context, and submit approved text through Claude’s import flow. Then inspect the resulting memory entries and edit or remove anything inaccurate. Anthropic describes the feature as experimental and says imported memories may not always be incorporated successfully.
Use account-wide instructions for durable communication preferences and general operating rules. Use Project instructions and knowledge for a particular client, product, team, or workstream. Convert vague directions into observable requirements by specifying required sections, maximum length, citation expectations, missing-information behavior, and escalation conditions.
For example, replace “be helpful and concise” with: “Return a three-bullet summary, cite the supplied source for factual claims, and ask one question rather than guessing when a required input is missing.” The first instruction is difficult to test. The second gives you a format, a source-use rule, and a defined exception path.
Keep source material and instructions distinct. A preference about tone is not a project reference file, and a file does not define what the assistant should do with it. If a Project uses retrieval to work with a larger knowledge base, test whether the relevant document is retrieved rather than assuming every file is loaded into every response.
Rebuild custom GPTs by function, not by name
No automatic custom GPT migration to Claude was verified in the reviewed documentation, and a Claude Project is not a guaranteed functional equivalent. Before rebuilding a frequently used GPT, inventory its instructions, knowledge files, conversation starters, capabilities, apps, actions, permissions, and expected outputs. OpenAI’s documentation on creating and editing GPTs and GPT components and behavior describes these elements. Availability of GPT creation and management can depend on the account or workspace.
Then classify each component:
- Global behavior may belong in Claude account instructions.
- Scoped behavior and reference files may belong in a Claude Project.
- A repeatable procedure may suit a Claude Skill or versioned prompt template.
- An external action requires a separately verified target tool and permission.
Preserve the original configuration. Test file retrieval, citations, structured output, and every external dependency independently. Anthropic’s Skill guide explains how to create Skills, but it does not promise conversion from custom GPTs.
Copying a GPT’s prompt and reference files does not recreate executable actions, connected services, or permissions. Create a component inventory first, then verify that a suitable Claude capability and authorized connection exist for each dependency.
Run acceptance tests before relying on the new setup
Choose five to ten recurring tasks and run them in Claude with representative inputs. Define pass criteria before testing. Check required sections, tone, factual and citation behavior, handling of missing information, structured-output validity, file retrieval, and any required escalation.
When a test fails, route the correction to its owner: account instruction, Project instruction, knowledge file, prompt or Skill, or tool dependency. Save the correction as a versioned rule or prompt example with its source and review date instead of adding every fix to global memory. Measure task success and correction frequency over a defined review period.
- Use representative recurring tasks, not only a memory-recall prompt.
- Check required output sections, tone, citations, and structured fields.
- Confirm Claude retrieves the intended Project file and uses it appropriately.
- Test what happens when a required source or input is missing.
- Name a human owner for unresolved failures, sensitive-data decisions, and tool permissions.
If you automate record handling later, separate raw source observations, approved instructions, reported summaries, and test results. Do not treat one import as one conversation or one account as one row. For concurrent imports, generate an import-run ID and enforce uniqueness in the database or use a transactional upsert. A lookup followed by an insert can create duplicates when two runs overlap.
For example, a source conversation highlight might use the source platform, account or workspace, conversation ID, message ID, and import-run ID. A prompt template needs its own prompt key and version. A file needs a source file ID or content hash. If multiple conversations contain the same lesson, retain separate evidence rows and link them to a deduplicated canonical instruction. These are proposed implementation choices, not vendor-published migration fields.
The documented workflows here are user-interface processes, not a verified direct ChatGPT-to-Claude migration API. If you are designing a separate automated workflow, AI agent implementation requires defined inputs, permissions, validation, and human review.
Common questions about ChatGPT-to-Claude context transfer
Can I transfer all my ChatGPT conversations directly into Claude?
Not through the verified Claude memory-import flow. Anthropic documents importing context text, not reconstructing the full ChatGPT conversation history inside Claude. Use the ChatGPT export as a backup and extraction source, then select and place useful material deliberately.
Should I paste the entire export into Claude?
No. Inspect the archive, create a structured and redacted working package, and import only the material needed for the intended account or Project. Do not assume every export has the same archive structure.
Will Claude import my custom GPTs automatically?
No automatic conversion was verified. Extract the GPT’s instructions, knowledge files, capabilities, actions, and expected behavior. Rebuild only the relevant parts in Claude account instructions, Projects, Skills, or separately verified tools.
Will Claude Projects share context across all my work?
No. Project instructions and knowledge are scoped. Add relevant material to each Project that needs it, and do not expect unrelated Projects or chats to share it automatically.
Does Claude memory retain everything imported from ChatGPT?
There is no such guarantee. Anthropic describes memory import as experimental and says imported memories may not always be incorporated. Review the individual entries after import and remove or correct errors.
How large is Claude’s context window?
Capacity depends on the model, plan, client, and feature. Anthropic’s current paid-plan documentation lists model configurations with 200K, 500K, or 1M-token context windows. Check the selected model and product rather than relying on one universal figure.
Can I automate ChatGPT-to-Claude migration through an API?
The reviewed official documentation verifies user-interface export and import workflows, not a universal direct migration API. Verify current APIs, authentication, workspace permissions, privacy terms, and target-side write capabilities before designing automation.
What if Claude interprets a migrated preference differently?
Run a calibration task with a representative input. Compare the result with explicit acceptance criteria, then rewrite the preference as an observable requirement with an example and a defined failure condition.