> ## Documentation Index
> Fetch the complete documentation index at: https://docs.summerengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Upload your build and publish

> Upload a store bundle, web build or download to Summer Games with the Summer MCP, wait for the checks, preview the page and go live with summer_go_live after the owner says yes.

After the store page is filled and the game is exported, your agent uploads the build and publishes. In Studio you do the same under **Check and publish**; see [Publish your game](https://docs.summerengine.com/build/publish.md). Every input of these operations: [Store and publishing operations](https://docs.summerengine.com/mcp/operations/store.md).

![Your export is uploaded in resumable 64 MiB parts. Summer checks it on iPhone, Android, Mac and Windows. Then summer\_go\_live shows you the page and build, and the game goes live after your yes, once the checks pass.](https://mintcdn.com/summer-18f03259/u2XgseMDTiPPbFru/images/guide-art/publishing/upload-light.svg?fit=max\&auto=format\&n=u2XgseMDTiPPbFru\&q=85\&s=67fbb81cb910b0bbe1c504988f22b097)

## 1. Upload the build

With the npm MCP on your computer, `summer_publish_build` (operation `store.upload_file`) uploads the file from your disk: a store bundle, a web build or a download. The first call shows what it will upload. Show it to the owner; the second call, with `confirm: true`, uploads it after they approve this exact file and version.

```json title="1. Preview" theme={null}
{ "tool": "summer_publish_build", "gameId": "<gameId>", "clientVersion": "v1.0.0" }
```

It returns the exact game, file, SHA-256, size and version.

```json title="2. Upload" theme={null}
{ "tool": "summer_publish_build", "gameId": "<gameId>", "clientVersion": "v1.0.0", "confirm": true }
```

| Input | Meaning |
| - | - |
| `gameId` | The store game. Omit it to get the list of your games. |
| `file` | The `.zip`. Defaults to the last `summer_export_game` result. |
| `clientVersion` | `vMAJOR.MINOR.PATCH`. A new upload needs a new version. |
| `platform` | Web builds and downloads: `web`, `macos-universal`, `windows-x64` or `linux-x64`. Defaults to the last export's platform. Omit it for a store bundle. |
| `confirm` | `true` uploads. Without it, the call only shows what it will upload. |
| `publish` | Leave `false`. Go live with `summer_go_live`. |
| `waitSeconds` | How long to wait for Summer's checks (default 600). On timeout, call again to keep waiting. |

Store bundles upload in 64 MiB parts, web builds in 16 MiB parts. If the connection drops, call it again with the same file and version: it continues the same upload and skips the parts already stored.

Web builds and downloads are **store versions**, one per platform. A web `.zip` is checked before upload: `index.html` at its root, at most 2,000 files and 500 MiB.

> [!WARNING]
>
> On a game that is already live, a finished web build or download goes live at once. So on a live game only the owner can finish one, in Studio.

**Without the npm MCP** (a hosted agent that has the file elsewhere), run three operations with `summer_call`. They take one `uploadId` for every kind:

1. [`store.upload_begin`](https://docs.summerengine.com/mcp/operations/store#upload_begin) with `gameId`, `kind` (`bundle`, `web` or `download`) and `sizeBytes`. It returns the `uploadId` and the part plan.
2. [`store.upload_sign_parts`](https://docs.summerengine.com/mcp/operations/store#upload_sign_parts) with `gameId`, `uploadId` and `parts`. PUT each part to its URL with every returned header.
3. [`store.upload_complete`](https://docs.summerengine.com/mcp/operations/store#upload_complete) with `gameId` and `uploadId`. It answers a job: wait with `summer_jobs_wait` until it is `done` or `failed`.

## 2. Wait for the checks

`summer_store_status` shows every upload and its state: `uploading`, `processing`, `checking`, `ready` or `failed`. Summer checks a bundle on every platform it lists. A failed upload says what to fix; see [Troubleshooting](https://docs.summerengine.com/publishing/summer-games-troubleshooting.md).

## 3. Look at it first (optional)

```json theme={null}
{ "op": "store.preview_link", "input": { "gameId": "<gameId>", "expires": "1d" } }
```

A private link to the saved page on summer.games. It is hidden from search, and Buy and Play do nothing. It expires after `1h`, `1d` or `7d`.

## 4. Check what is missing

`summer_store_get_listing` returns the publish checklist for each store. Fix everything it lists before you go live. Read it again after each change.

## 5. Go live

`summer_go_live` (operation [`store.go_live`](https://docs.summerengine.com/mcp/operations/store#go_live)) takes the game live. The first call shows what will go live: the page and the build.

```json title="1. The plan" theme={null}
{ "tool": "summer_go_live", "gameId": "<gameId>", "publicationId": "<from summer_publish_build>" }
```

Show the plan to the owner and ask them. Only after they say yes, call it again with `confirm: true`:

```json title="2. Go live" theme={null}
{ "tool": "summer_go_live", "gameId": "<gameId>", "publicationId": "<from summer_publish_build>", "confirm": true }
```

| Input | Meaning |
| - | - |
| `gameId` | The store game. Omit it to get the list of your games. |
| `publicationId` | The build to release, from `summer_publish_build`. Defaults to the newest uploaded export. |
| `confirm` | `true` only after the owner said yes to this exact page and build. |
| `waitSeconds` | How long to watch before answering (default 600). |

It releases the build to every platform that passed its checks, publishes the store page, and watches until players get it. The game is live as soon as Summer's automatic checks pass. There is no review to wait for. Web builds and downloads go live with the page.

* `live`: the game is on Summer Games. Give the owner the page link.
* `waiting`: call it again to keep watching. With `waitingOn: "summer"`, every check passed and Summer is finishing the launch: nothing to fix.
* A failed check: it names the check and its fix. Fix it, upload again, and go live again.
* `needs_permission`: **Publish** is off for agents on this account ([Agent permissions](https://docs.summerengine.com/mcp/permissions.md)). Ask the owner to click **Publish** in Studio.

The price comes from the store page. To change it, see [Pricing](https://docs.summerengine.com/mcp/operations/pricing.md).

## Updates

Export again with a new version, upload it the same way, and go live again. Players keep the current version until the new one is live.

## Ask your agent

**Upload my build and take it live.** Your agent uploads, waits for the checks and asks you before it goes live.

Upload my exported game to Summer Games and publish it. Use the Summer
Engine MCP and follow
[https://docs.summerengine.com/publishing/upload-and-submit.md](https://docs.summerengine.com/publishing/upload-and-submit.md).

* Upload each export with store.upload\_file and version
  \[VERSION, for example "v1.0.0"].
* Wait until every build is ready. If one fails, tell me why.
* Check the store page's checklist and fix what is missing.
* Show me what will go live and ask me. Go live only after I say yes.
* Tell me the game is live only when summer\_go\_live says so.

***

Does this not help you? [Reach out on Discord!](https://discord.gg/summerengine)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.