# Bring your projects to Playground

This guide is for the coding assistant helping a signed-in Playground member import their own work. Prepare a collection of the member's selected projects. Completed website uploads publish immediately; do not alter original repositories.

## What access is needed

Use whichever assistant you have access to now. The original creation provider is not an import requirement: Codex or another coding assistant can package accessible files made with Claude, even after a Claude subscription is cancelled. This does not grant access to unavailable cloud conversations or recover deleted accounts.

**Do not let a blocked web reader stop the export.** The copied Playground prompt includes the collection format and limits. Use those instructions without fetching this guide. The downloadable `playground-import-kit.zip` contains this guide, schema, packaging helper and a manifest example for offline use. Save the collection first; browser automation is optional and comes last. If it fails, return the saved collection for manual upload.

For projects still in Claude, download individual artifact/source files. Claude also supports account exports from Settings → Privacy, including free accounts; these contain conversation/account data and are not guaranteed runnable projects. Recover only the relevant code and assets locally. Never upload an entire account export to Playground. See [Claude artifact downloads](https://support.claude.com/en/articles/9487310-what-are-artifacts-and-how-do-i-use-them) and [Claude data exports](https://support.claude.com/en/articles/9450526-export-your-claude-data).

A prompt is an instruction, not an account permission grant. Use only project files, artifacts, repositories and session tools actually available in this task. In Codex, ask the member to select missing folders or approve the access it needs. In ChatGPT, use the conversation containing the build, attached project files, or source files the member supplies. A ChatGPT sign-in to Playground does not provide chat history or files. No provider API key is needed for this transfer.

Look for all distinct projects, including unpublished work and games, across the member's selected accessible locations. When session/history tools are available, check recent and archived project tasks for source locations and dates. Never pretend to have searched unavailable chats/accounts. Do not export raw conversations. Report locations checked, included projects, missing projects and next steps.

## Produce a collection

Create actual downloadable `playground-projects-01.json` files. Use code to ZIP source/build folders and base64-encode binary data. The format is described by `/playground-collection.schema.json`.

```json
{
  "version": 1,
  "projects": [{
    "source_id": "stable-original-project-id",
    "title": "My project",
    "summary": "A factual summary of what it does.",
    "description": "What it does, setup instructions, missing pieces and any uncertain dates.",
    "category": "Tools",
    "tags": ["AI Tool"],
    "date": "2026-09-01T12:00:00Z",
    "license": "All rights reserved",
    "remix": false,
    "provider_requirements": []
  }]
}
```

Replace examples with real project information. Keep one latest copy per distinct project. Keep `source_id` stable across retries/exports: use an existing project ID, repository identity, or locally saved UUID. Different projects need different IDs even when titles match. Original dates must be based on source/session evidence; ask if unknown, or identify an agreed estimate in the description. Completed uploads publish immediately.

Include a real preview image for each project. Use an actual screenshot of the working interface or artwork from that project. Capture with available browser tools; avoid personal account data, login screens and error states. If no image is available, continue; screenshots are optional.

Project fields:

- `source`: raw base64 ZIP of permitted project source.
- `build`: raw base64 ZIP of a compiled browser website, with `index.html` at the root or inside its output folder.
- `cover`: `{ "mime": "image/png", "data": "RAW_BASE64" }`. JPEG and WebP also work.
- `repo_url`: root GitHub repository URL. Private repositories are not fetched by Playground; include source/build files obtained through the member's authorized access instead.
- `live_url`: public HTTPS app URL. A chat/share link is not a hosted application.
- `creation_details`: Try to fill optional creation_details with the model that did most of the building and the coding app/harness, for example {"tools":["Claude"],"model":"Opus 5.5 (estimated)","harness":"Claude Code"} or {"tools":["Codex"],"model":"Astra 6, high reasoning","harness":"Codex app"}. These are free-form credits, not a list of supported models. Include version or reasoning/effort details when known (up to 100 characters each for model and harness); a reasonable estimate from your work on this project, creator input, or obvious project-specific build notes is welcome. Supported tools: Claude, Codex, ChatGPT, Cursor, Other. Any field may be omitted or left empty. Do not delay publishing to investigate or ask for exact versions. Preserve existing credits on updates unless there is a reason to change them; a small edit or simply exporting a project does not make the current assistant its primary builder. API dependencies identify runtime services, not the coding model. Do not upload transcripts or private evidence.

- `creation_details.primary_device`: optional `desktop`, `mobile`, `both`, or `unspecified`. Use creator confirmation or project-specific documentation and verified controls/layout. Do not infer support from responsive CSS or the device doing the export. Use `both` only when both devices are intended and usable; omit the field or use `unspecified` when unknown.

Include optional creation_details.services as [{"name":"Service name","purpose":"What this project uses it for","url":"https://public-service-website.example/"}]. List up to 12 third-party services used to build or run the project, such as asset generation, 3D models, animation, payments, databases, authentication or hosting. Use source integrations, README/setup notes, asset provenance, or creator confirmation as evidence; a mention, link, installed but unused package, or guess is not enough. Names: 1–80 characters; purposes: 1–240 characters; website: optional public HTTPS URL up to 500 characters, without credentials, query parameters or fragments. No secrets or private account links. Each name may appear only once. If only services are known, set tools:[] and model:"". Omit unknown services; do not claim there are none. Services are credits and dependencies, not authorization to require API keys; provider_requirements remains separate.
- `provider_requirements`: `[{"provider":"openai","model":"actual-model-id"}]`; supported providers are `openai`, `anthropic`, `google`, `tripo`. These are optional confirmed runtime overrides. Playground automatically checks source for services; include asset-generation scripts and provenance notes in the source so offline asset tools are credited without requiring visitor keys. Never include keys. The hosted app needs the Playground AI bridge described in `/project-ai-guide.md` to use visitor-supplied keys.
- `license`: `MIT`, `Apache-2.0`, `CC-BY-4.0`, or `All rights reserved`. Preserve an existing license; use All rights reserved / remix false if ownership or terms need review.
- `remix`: boolean; the importer turns this off for All rights reserved.

Do not include publication/access/account fields. Collections uploaded on the website publish when complete, with unshared source. Explicitly private legacy sync connections retain their private import contract. Omit `mode`; `mode:"sources"` is a different workflow for intentionally updating already-public remix archives, and must not be used for onboarding.

## Limits and runnable builds

- Collection: 1–50 projects, no more than 50 MiB JSON including base64. Split larger collections.
- Title: 1–100 characters. Summary: 1–240. Description: up to 12,000.
- Categories: Tools, Games, Websites, Developer Tools, Design & Creative, Music & Audio, Video & Animation, Writing & Content, Education, Research, Health & Fitness, Finance, Commerce, Social & Community, Other. Choose one based on what the project does. Older category labels are accepted and mapped to this list. Tags: up to 5, each 1–36 characters. Suggest descriptive tags; avoid generic repeated tags.
- Source ZIP: no more than 10 MiB compressed, 50 MiB unpacked, 1–2,000 files.
- Website ZIP: no more than 10 MiB compressed and unpacked, up to 150 supported web files, each up to 3 MiB.
- Preview: PNG, JPEG or WebP, no more than 100 MiB.

An index.html importing uncompiled JSX/TSX is not a browser build. Use the existing project build instructions when available, preserving the original project. Do not claim it works without verification. If the project cannot be built, include its available source/metadata and explain what is missing. Server apps and backend-dependent websites can be saved but may need additional setup to run. Hosted previews block direct external networking except the Playground AI bridge. External app URLs always show the current external app, not a frozen export.

Exclude secrets, API keys, .env files (including .env.example), personal user data, chat transcripts, Git history, dependencies and caches. Include safe setup instructions and environment-variable names in a Markdown file instead. Review the selected files; filename filters and token checks are not a complete secret scan.

## Optional local folder packager

Download `/pack-playground.py`, inspect it, and use Python 3.9+ locally. It does no network calls and uploads nothing. It only packages explicitly named directories; it does not discover other folders or grant access.

Create `manifest.json` using the collection metadata above plus `source_dir`, `build_dir` and optionally `cover_file` paths. Relative paths resolve from the manifest's folder. For example:

```json
{"projects":[{
  "source_id":"my-stable-project-id",
  "title":"My project",
  "summary":"What this real project does.",
  "description":"Setup and limitations.",
  "category":"Games",
  "tags":["Fantasy Game"],
  "date":"2026-09-01T12:00:00Z",
  "license":"All rights reserved",
  "remix":false,
  "source_dir":"./my-project",
  "build_dir":"./my-project/dist"
}]}
```

Run `python3 pack-playground.py manifest.json --output playground-export`. The helper creates numbered collection files and a local report. It omits hidden files, dependencies, common credentials and symlinks. A missing or invalid optional source/build/image does not discard the whole project: valid metadata and other safe artifacts are retained, and the report names what needs attention. A detected credential causes that entire artifact to be omitted. Source archives retain visible dist/build/out folders because some projects keep their editable code there. Review the output and report before importing. Keep the report local: it may contain filenames that do not belong in the collection. Complete missing artifacts before import when possible. A manual collection import with the same stable source_id can fill missing source, screenshot or website build in an unreviewed inbox project. It preserves existing files and metadata. Reviewed/private/published projects are not changed. Automatic sync continues to skip completed imports; use manual collection import or Review → add files to complete them.

## Import existing files directly

The project inbox also accepts up to 10 individual project ZIP, HTML, JSX or TSX files, totalling at most 50 MiB. Choose one file per project and review its name, TLDR and original date. Unknown dates default to the import date and are marked as unknown. Files are read locally until **Upload & publish** is clicked. No provider subscription, API key, or assistant is needed for files already downloaded.

ZIP files must be clean source exports without dependencies, Git history or secrets. HTML files are wrapped as index.html; JSX/TSX source is saved but needs compilation to become a browser preview. Playground checks ZIP/HTML files for a usable web build when completing the upload. If preview setup fails, the public listing shows the next step; source remains unshared. Exact duplicate files are skipped; this route does not overwrite existing projects. A preview image is optional.

## Import and review

Return the generated collection file(s) and the coverage report to the member. In their signed-in Playground page, open **Import projects / Project inbox**, choose a collection, select projects, and click **Upload & publish selected**. If browser tools are available and the member has authorized importing the selected files, the coding assistant can perform these same steps using the browser. Do not extract cookies or request credentials. Otherwise the member downloads the file and uploads it themselves.

The importer validates the collection before starting. Completed projects are skipped on retries; unfinished projects can resume. Stable IDs prevent duplicate projects across collection files. Source and website files supplied in the collection take precedence over GitHub's current branch. Review any per-project errors. Return the actual public links. Source downloads and remix permissions remain separate.

Reference: [OpenAI: projects and file access](https://learn.chatgpt.com/docs/projects).

## Repeat imports with Sync

Open `/#sync` and click **Sync all** to check every connected export folder (including subfolders) and saved public GitHub username. Choose **Copy prompt** under Codex, ChatGPT / OpenAI or Claude to ask that assistant to check its accessible folders, sessions and repositories for newly created or not-yet-exported projects. Open the app and send the prompt yourself. Opening an app does not scan an account or grant access.

Save collections with stable `source_id` values as `playground-projects-01.json` (numbered parts if needed) or `name.playground.json`. Write completed files atomically. Connect a parent export folder to include collections up to 8 subfolder levels deep. Hidden and dependency folders are skipped. A connection accepts up to 50 collection files, 100 MiB total, and 50 MiB per collection; large folder trees are bounded at 10,000 entries. Results identify limits or inaccessible files rather than claiming a complete scan. Raw source files and chat transcripts are not uploaded by folder sync.

Connected folders and GitHub usernames are saved in this browser for the signed-in Playground account. Enabled folder connections check when the tab becomes visible and every minute while it remains visible. GitHub checks run on a manual **Sync all**, include public forks, and paginate up to 1,000 repositories per username. At most 100 new repositories per username are imported in a run; run again to continue. Private repositories require an assistant export from a tool that already has access.

New projects stay private; existing projects keep their saved versions. Already imported catalog projects resume interrupted imports using stable source IDs. GitHub repository duplicates are skipped. A source connection does not contact provider history services or install a local background process; the assistant must export new work before it can arrive here.