---
title: "How to Deploy an App Built with Claude Code on App Platform | Hostman Docs"
description: "Step-by-step guide to deploying an app built with Claude Code on Hostman App Platform. Set up GitHub MCP, push your code from the chat window, and go live in minutes—no prior experience with git or deployment needed."
---

> For the complete documentation index for AI agents, see [llms.txt](https://hostman.com/llms.txt).

You've built something in Claude Code and now you want to put it online. This guide walks you through the full process: pushing your project to GitHub and deploying it on Hostman App Platform.

Along the way, you'll also set up MCP—a protocol that lets Claude Code interact with your GitHub account directly from the chat window. With it, you can create repositories and push code without touching git manually.

No prior experience with GitHub or deployment required. Just follow the steps in order.

## Before You Begin

You will need the following:

-   **A project built with Claude Code** that's ready to deploy.
-   **A GitHub account**. You'll create one in Step 1 if you don't have one yet.
-   **A Hostman account**. Sign up at [hostman.com](https://hostman.com/signup/) if needed.

## Step 1. Create a GitHub Account

GitHub is where your project's code will live. You'll need an account there so Hostman can access and deploy your app.

Already have one? Skip to **Step 2**.

1.  Go to [github.com](https://github.com) and click Sign up.
2.  Register with your Google account, Apple ID, or an email address.

Once you're registered and logged in, you will see your [dashboard](https://github.com/dashboard).

![0902d2f9 709a 41df B496 De8fb6ff0a11.png](https://content.hostman.com/assets/1fb8456b-5bb6-4223-9231-66021cafbf3f.png?width=1999&height=1142)

## Step 2. Check and Install the Claude Code CLI

To set up MCP, you need the command-line version of Claude Code. This is separate from the Claude desktop app or Cowork—even if those are installed, the CLI may not be.

Open your terminal (or PowerShell on Windows) and run: 

```shell
claude --version
```

If you see a version number, you're good to go. If the command isn't found, install it:

**macOS**

```shell
curl -fsSL https://claude.ai/install.sh | bash
```

**Windows**

```shell
irm https://claude.ai/install.ps1 | iex
```

On Windows, the installer may show a message like:

```shell
Native installation exists but C:\Users\Administrator\.local\bin is not in your PATH. Add it by opening: System Properties → Environment Variables → Edit User PATH → New → Add the path above. Then restart your terminal.
```

If that happens, add the directory to your `PATH`:

```shell
setx PATH "$($env:PATH);C:\Users\$env:USERNAME\.local\bin"
```

Then close the terminal, reopen it, and run `claude --version` again. If you see a version number, you're all set.

## Step 3. Create a Personal Access Token

Issuing a **Personal Access Token** will let Claude Code interact with GitHub on your behalf. The token allows Claude Code to create repositories and push code from the chat window.

1.  Open GitHub and click your profile icon in the top-right corner.
2.  Select **Settings**.
3.  In the left sidebar, scroll to the bottom and click **Developer settings**. Then go to **Personal access tokens** → **Tokens (classic)**.
4.  Click **Generate new token** → **Generate new token (classic)**. If GitHub asks for your password, enter it and continue.

![Personal Access Tokens Classic 05 20 2026 10 50 Am 06 04 2026 05 00 Pm](https://content.hostman.com/assets/fcb6aa29-1079-4149-827e-8070eb8ceb89.png?width=1898&height=858)

5.  Give the token a name in the **Note** field—something like `claude-code-access` so you know what it's for later.
6.  Set an expiration date in the **Expiration** field. If you don't want to go through this process again, pick **No expiration**.
7.  Under **Select scopes**, tick the permissions Claude Code will need:
    -   `repo`: lets it create, edit, and push to repositories
    -   `admin:org`: only add this if you're working with organisation repositories
8.  Click **Generate token**.

> [!NOTE]
> GitHub shows the token exactly once. Copy it now and keep it somewhere safe.
>
> Keep your token private. Anyone with this token can perform actions on your GitHub account. If you ever suspect it's been exposed, go to [GitHub settings](https://github.com/settings/tokens), delete it, and create a fresh one.

## Step 3. Set Up the GitHub MCP Server

This step connects GitHub to Claude Code via MCP, so you can create repositories and push code directly from the chat.

We'll use the local GitHub MCP server—no GitHub Copilot, Docker, or Node.js required. Just a binary you download once.

### macOS

Open your terminal and create a folder for the server:

```shell
dir="$HOME/.local/github-mcp-server"
mkdir -p "$dir"
```

Download and unpack the binary. The command below automatically picks the right version for your architecture (Apple Silicon or Intel):

```shell
case "$(uname -m)" in
 arm64) archive="github-mcp-server_Darwin_arm64.tar.gz" ;;
 x86_64) archive="github-mcp-server_Darwin_x86_64.tar.gz" ;;
 *) echo "Unsupported architecture: $(uname -m)" && exit 1 ;;
esac
​
url="https://github.com/github/github-mcp-server/releases/latest/download/$archive"
tarball="$dir/gh-mcp.tar.gz"
​
curl -L "$url" -o "$tarball"
tar -xzf "$tarball" -C "$dir"
rm "$tarball"
chmod +x "$dir/github-mcp-server"
```

Confirm the server runs correctly:

```shell
"$dir/github-mcp-server" --version
```

You should see a version number.

Now register the server with Claude Code. Replace `YOUR_TOKEN` with the token from the previous step:

```shell
claude mcp add github -s user \
  -e GITHUB_PERSONAL_ACCESS_TOKEN=YOUR_TOKEN \
  -- /Users/YOUR_USERNAME/.local/github-mcp-server/github-mcp-server stdio
```

### Windows

Open PowerShell and create a folder for the server:

```shell
$dir = "$env:USERPROFILE\.local\github-mcp-server"
New-Item -ItemType Directory -Force -Path $dir | Out-Null
```

Download and unpack the binary:

```shell
$url = "https://github.com/github/github-mcp-server/releases/latest/download/github-mcp-server_Windows_x86_64.zip"
$zip = Join-Path $dir "gh-mcp.zip"

Invoke-WebRequest -Uri $url -OutFile $zip -UseBasicParsing
Expand-Archive -Path $zip -DestinationPath $dir -Force
Remove-Item $zip
```

> [!NOTE]
> The `x86_64` build works for most Windows machines. If you have an ARM processor, use `github-mcp-server_Windows_arm64.zip` instead.

Confirm the server runs correctly:

```shell
"$dir\github-mcp-server.exe" --version
```

Now register the server with Claude Code. Replace `YOUR_TOKEN` with your token:

```shell
claude mcp add github -s user `
  --env GITHUB_PERSONAL_ACCESS_TOKEN=YOUR_TOKEN `
  -- "$dir\github-mcp-server.exe" stdio
```

### Verify the Connection

Run the following to confirm the server is connected:

```shell
claude mcp get github
```

Look for `Status: ✓ Connected` in the output.

Then restart Claude Code in your project folder and test MCP in the chat by asking: _What GitHub MCP tools do you have access to? List all of them._

![Image2](https://content.hostman.com/assets/e2b61d4d-fa4e-4d86-9407-1f6c6200c6b4.png?width=1999&height=1323)

If Claude Code returns a list of tools, the integration is working correctly. If something seems off, ask Claude Code to check the MCP configuration and explain what's wrong.

## Step 5. Push Your Project to GitHub

With MCP set up, you can create a repository and push your code without leaving Claude Code.

1.  Open your project chat and ask Claude Code to create a repository: _Create a new public repository on GitHub called `hostman-test-app`._ 
2.  Claude Code will ask for permission before taking action—confirm it. The repository will then appear in your GitHub account.
3.  Next, push your project to the repository: _Push the project from the current directory to this repository using GitHub MCP._

If your project files aren't in the root directory, specify the folder in your message.

> [!NOTE]
> Make sure to mention GitHub MCP explicitly. Without it, Claude Code may try to use your local git installation—and if git isn't set up, the push will fail.

4.  Confirm the action when prompted, then open the repository on GitHub to verify your files are there.

## Step 6. Deploy on Hostman App Platform

Now it’s time to deploy your app.

1.  Open the [Hostman dashboard](https://my.hostman.com) → **App Platform** → **Create App**.
2.  Choose your app type: **Frontend**, **Backend**, or **Docker**, then select the framework your app uses.

> [!NOTE]
> Not sure? Ask Claude Code: _What framework is this project using?_

3.  Connect your repository:
    -   On the **Repository** step, click the GitHub icon.
    -   Sign in and authorize access.
    -   Select your repository from the list.
4.  Keep **Build by last executed commit enabled**. This way, Hostman will automatically redeploy the app whenever you push new changes.
5.  Choose a deployment region.
6.  Configure your app settings. What's needed here depends on your project type. Ask Claude Code if you're unsure. For reference, see the Hostman docs: [Frontend](https://hostman.com/docs/app-platform/frontend-apps/) · [Backend](https://hostman.com/docs/app-platform/backend-apps/) · [Dockerfile](https://hostman.com/docs/app-platform/dockerfile/) · [Docker Compose](https://hostman.com/docs/app-platform/docker-compose/).
7.  Click **Create** and wait for the deployment to finish.

## You're Live!

Once deployment completes, go to **Dashboard** and find your app's public URL in the **Domain** field. To [use a custom domain](https://hostman.com/docs/app-platform/managing-apps/#custom-domain), head to **Settings**.

Once everything is wired up, shipping updates is straightforward:

1.  Make changes to your project in Claude Code.
2.  Ask Claude Code: _Commit the changes and push to GitHub using MCP._
3.  Hostman detects the new commit and redeploys automatically.

Your entire workflow runs through the chat. No manual git commands, no extra steps.