EngineeringCategory

Deploy a Node.js app to GoDaddy from your terminal, or let your coding agent do it

•16 min read
Gary Robert

Most of the Node.js apps I see these days weren't written in an IDE, line by line. They were built in Claude Code, Cursor or another coding agent, in a terminal, in an afternoon. Then the builder hits the wall: the app works locally, and now they have to learn something new to get it online.

We recently launched GoDaddy Node.js Hosting, and the part I'm most excited about is that you never have to leave the terminal. Everything you can do in the dashboard you can also do with the GoDaddy CLI, gddy, and because gddy ships with an agent skill, your coding agent can run it for you.

In this post we'll take a minimal Node.js app (a few lines of Express) and host it on GoDaddy. We'll create a hosting app, upload the code, check it on a private preview, connect a Web Hosting plan, and publish it to a live site anyone can visit. Then we'll set an environment variable, ship an update, and point a domain at it. You can do all of that two ways:

  1. By hand with the CLI: about ten commands, most of them status checks, from a folder on your laptop to a public URL with an SSL certificate.
  2. With a coding agent: install one skill, then ask in plain language.

Both paths use the same platform and the same commands. The agent just types them for you.

Prefer to watch? The five-minute video walkthrough shows the agent path from an empty folder to a live site on its own domain.

What we'll cover

Before you start

You need:

  • A Node.js app. Anything that runs with npm start: Express, Fastify, Nest, Next.js, Nuxt, Remix, or a static React or Vue build.
  • A GoDaddy account. Previews are free. Publishing to a public URL needs a Web Hosting plan, which you can buy from the CLI (step 6 shows how).
  • macOS, Linux or Windows with a terminal.

Check that your app is ready

There's no Dockerfile or YAML to write. The platform reads your package.json, so make sure it has:

RequirementWhy
name, version and main fieldsIdentifies the app and its entry point
A build scriptThe platform runs npm run build. No compile step? Use "build": "echo build"
A start scriptThe platform runs npm start and keeps the process running
Runtime packages in dependenciesOnly dependencies are installed, so anything in devDependencies won't be there at runtime
Your server listens on process.env.PORTThe platform assigns the port. A hardcoded port won't receive traffic

Here's the minimal Express app I'll deploy in this post:

{
  "name": "hello-gd",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "build": "echo build",
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.21.2"
  }
}
const express = require("express");

const app = express();
const port = process.env.PORT || 3000;
const greeting = process.env.GREETING || "Hello from GoDaddy Node.js Hosting";

app.get("/", (req, res) => {
  res.send(`<h1>${greeting}</h1><p>Node ${process.version}</p>`);
});

app.listen(port, () => console.log(`listening on ${port}`));

The full checklist is in Node.js app requirements.

Part 1: Deploy with the gddy CLI

Here's the whole deploy by hand, from installing the CLI to a live URL. Each step shows the commands to run and what you should see back.

1. Install the CLI

gddy is a single binary for macOS, Linux and Windows, and it installs with one command.

On macOS or Linux:

curl -fsSL https://github.com/godaddy/cli/releases/latest/download/install.sh | bash

On Windows (PowerShell):

irm https://github.com/godaddy/cli/releases/latest/download/install.ps1 | iex

The installer puts gddy in ~/.local/bin and doesn't touch your PATH, so add it if your shell can't find the command:

export PATH="$HOME/.local/bin:$PATH"
gddy --version

This post uses gddy 0.2.25. Run the install command again any time to update.

2. Sign in

You don't have to sign in ahead of time. The first command that needs your account opens a browser window for you to log in, and later commands open it again when they need a new permission (the CLI asks for permissions one at a time, as each command needs them). That works fine; you'll just approve a few consent screens as you go.

If you'd rather approve everything once, request all the hosting and checkout permissions up front:

gddy auth login \
  --scope hosting.application:create --scope hosting.application:read \
  --scope hosting.source:write --scope hosting.source:read \
  --scope hosting.subscription:read --scope hosting.subscription:write \
  --scope hosting.deployment:execute \
  --scope hosting.secret:read --scope hosting.secret:write \
  --scope hosting.log:read \
  --scope shopping.catalog:read --scope shopping.checkout:execute --scope shopping.order:read

That's one browser window, one consent screen, and you're set for the rest of this post. Run gddy auth scope to see every permission and which commands need it, and gddy auth status to check who you're signed in as.

Deploying from CI? Use a Personal Access Token instead of browser sign-in. Set it in the GDDY_PAT environment variable and the CLI uses it automatically.

3. Create the app

Every deploy starts with a hosting app. It holds your code, its preview and production environments, and its settings. Create one and give it a name:

gddy hosting app create --app-type NODEJS --name hello-gd

Creating an app is asynchronous, so this returns an operation ID right away. Poll it until the status is COMPLETED, then note the app ID:

gddy hosting operation get --operation-id <operation-id>
app: {"id":"NODEJS-abc123xyz","status":"ACTIVE", ...}
operationId: 969pjmd
status: COMPLETED

In my test this was already COMPLETED on the first check, about 15 seconds after I ran create.

4. Zip and upload your code

From your project folder, zip everything except node_modules (the platform installs dependencies itself) and any .env files (secrets go in a separate step, below):

zip -r app.zip . -x "node_modules/*" -x ".env*" -x ".git/*"

Make sure package.json sits at the top of the zip, not inside a wrapper folder. Then upload it:

gddy hosting source upload --app-id NODEJS-abc123xyz --file ./app.zip
gddy hosting source status --app-id NODEJS-abc123xyz --import-id <import-id>

When the import reports COMPLETED, your app is built and running on its preview. Mine took about 20 seconds.

5. Check your preview

Ask the CLI for your app's details. The urls field has two addresses: a private preview, and the public URL your app will use once it's published.

gddy hosting app get --app-id NODEJS-abc123xyz
id: NODEJS-abc123xyz
name: hello-gd
status: ACTIVE
urls: {"preview":"https://host.godaddy.com/nodejs/projects/abc123xyz/preview","publish":"https://abc123xyz.c39.airoapp.ai"}

Open the preview link to see your app. The preview is private: it only opens for you, signed in to your GoDaddy account. You get two preview apps for free, with no plan and no credit card.

To confirm the app started, read its logs:

gddy hosting log list --app-id NODEJS-abc123xyz
TIMESTAMP                 LEVEL  MESSAGE
------------------------  -----  ----------------------
2026-10-07T16:13:17.419Z  INFO   > hello-gd@1.0.0 start
2026-10-07T16:13:17.419Z  INFO   > node server.js
2026-10-07T16:13:17.635Z  INFO   listening on 20010

That port is the one the platform assigned through process.env.PORT.

6. Connect a Web Hosting plan

Publishing needs a Web Hosting plan with a free app slot. Economy includes 1 published app, Deluxe 10 and Ultimate 25, with no per-request, per-GB or build-minute charges. You attach an app to a plan once; later deploys skip this step.

If you already have a Web Hosting plan, list your plans and pick one with availableSlots above 0:

gddy hosting subscription list --hosting-product=WEB_HOSTING
totalAvailableSlots: 10
items: {"tier":"DELUXE","slotLimit":10,"attachedCount":0,"availableSlots":10,"status":"ACTIVE","subscriptionId":"648f29a6-...", ...}

If you don't have one yet, buy one from the terminal. Search the catalog, create a checkout, review the price and agreements it shows you, then complete it:

gddy shopping catalog search --category webHosting
gddy shopping checkout create --item hosting-economyapi:1mo
gddy shopping checkout complete <checkout-id> --agree

checkout create doesn't place an order. It shows the price, the saved payment method it will use, and the agreement you're accepting, so you can review them first. Once the order completes, the new plan shows up in gddy hosting subscription list.

Then attach the app to the plan:

gddy hosting subscription attach --app-id NODEJS-abc123xyz --subscription-id <subscription-id>

7. Publish

With a plan attached, promote the build you just checked on preview to production, then check the deployment until it reports COMPLETED:

gddy hosting deployment publish --app-id NODEJS-abc123xyz
gddy hosting deployment get --app-id NODEJS-abc123xyz --deployment-id <deployment-id>

When the deployment is COMPLETED, open the publish URL from step 5. In my test that took about 30 seconds, and the app was live on HTTPS behind a CDN and web application firewall, with nothing extra to configure.

curl https://abc123xyz.c39.airoapp.ai
<h1>Hello from GoDaddy Node.js Hosting</h1><p>Node v22.23.3</p>

That's it: from a folder on your laptop to a public URL in about ten commands.

8. Add environment variables and secrets

Secrets are set separately for preview and production, encrypted, and never returned by the API. Set one for production, then restart so the app picks it up:

gddy hosting secret create --app-id NODEJS-abc123xyz \
  --name GREETING --value "Hello from production" --variant PUBLISH
gddy hosting app restart --app-id NODEJS-abc123xyz --variant PUBLISH

Leave off --variant and the secret goes to preview. Because the two are separate, you can point preview at test credentials and production at real ones.

9. Ship an update

To deploy a change, zip and upload again to the same app, check the preview, then publish:

zip -r app.zip . -x "node_modules/*" -x ".env*" -x ".git/*"
gddy hosting source upload --app-id NODEJS-abc123xyz --file ./app.zip
gddy hosting deployment publish --app-id NODEJS-abc123xyz

The live site keeps serving the old version until you publish, and your production secrets carry over. In my test an update went from upload to live in under 40 seconds.

To read production logs, add --variant PUBLISH:

gddy hosting log list --app-id NODEJS-abc123xyz --variant PUBLISH --level ERROR

Prefer GitHub to zip files? Create the app from your repository in the Node.js Hosting dashboard, then pull a branch into preview whenever you're ready to ship:

gddy hosting source github --app-id NODEJS-abc123xyz --repo OWNER/REPO --branch main

Pushing to GitHub doesn't redeploy on its own, so run this, then publish as usual.

10. Use your own domain

When you're ready for your own domain, attach it to the app. If the domain is registered at GoDaddy, the DNS records are set up for you. If it's registered somewhere else, the domain's details show exactly which records to add at your DNS provider. Either way, the SSL certificate is issued automatically.

gddy hosting domain attach --app-id NODEJS-abc123xyz --hostname example.com
gddy hosting domain get --app-id NODEJS-abc123xyz --domain-id <domain-id>

See Attach a custom domain for the details.

Don't have a domain yet? You can buy one without leaving the terminal. Check that the name is available, get a quote that shows the price and the agreement, then register it using the quote's token:

gddy domain available example.com
gddy domain quote example.com
gddy domain purchase --quote-token <token> --agree --confirm

See Register a domain for the full flow.

Part 2: Let your coding agent deploy it

If you built your app in Claude Code, Cursor, Codex or Windsurf, you don't need to memorize any of the commands above. gddy ships with an agent skill: a short instruction file that tells your agent how to use the CLI, how to look up any command it hasn't seen (gddy guide hosting walks through the whole deploy), and when to stop and ask you first. The agent runs gddy on your machine, signed in as you, so it can only do what you can do.

1. Install the CLI and the skill

Complete step 1 above to install gddy, then add the skill to your agent.

Claude Code:

claude plugin marketplace add godaddy/cli
claude plugin install gddy@godaddy

Cursor (or Codex, Windsurf, OpenCode and other agents that support skills):

npx skills add godaddy/cli --skill gddy --agent cursor

Swap cursor for codex, windsurf or opencode as needed. This installs the skill into the current project; run it from your app's folder.

You can sign in ahead of time with the gddy auth login command from step 2, or let the agent's first command open the browser for you.

2. Ask for a preview

Open your agent in your app's folder and tell it to:

Deploy this app to GoDaddy Node.js Hosting with the gddy CLI. Create an app called hello-gd-agent, upload this project to it, and give me the preview link.

Here's what Claude Code did in my test, in about a minute and a half. It loaded the skill, read the CLI help, and checked that I didn't already have an app with that name before creating one:

gddy hosting --help
gddy hosting app list --app-type NODEJS --filter "name=='hello-gd-agent'"
gddy hosting app create --app-type NODEJS --name hello-gd-agent
gddy hosting operation get --operation-id <operation-id>
zip -r /tmp/hello-gd-agent-source.zip package.json package-lock.json server.js
gddy hosting source upload --app-id NODEJS-abc123xyz --file /tmp/hello-gd-agent-source.zip
gddy hosting source status --app-id NODEJS-abc123xyz --import-id <import-id>
gddy hosting app get --app-id NODEJS-abc123xyz

Then it handed back the preview link and stopped. It told me it hadn't published because attaching a plan "may involve a purchase", and it would only do that if I asked.

3. Go live

If you already have a Web Hosting plan:

Looks good. Attach it to one of my existing Web Hosting plans that has a free slot, then publish it and give me the live URL.

gddy hosting subscription list --hosting-product WEB_HOSTING --fields all
gddy hosting subscription attach --app-id NODEJS-abc123xyz --subscription-id <subscription-id>
gddy hosting deployment publish --app-id NODEJS-abc123xyz
gddy hosting deployment get --app-id NODEJS-abc123xyz --deployment-id <deployment-id>
curl -sS https://abc123xyz.c38.airoapp.ai/

It picked a plan with free slots, skipped one that had lapsed and one about to expire, published, and loaded the live URL to check it before replying. About a minute and a half again.

If you don't have a plan yet:

I don't have a Web Hosting plan yet. Use the gddy CLI to show me which plans I can buy and what they cost.

The agent looked up the right commands, then searched the catalog:

gddy search hosting plan
gddy guide shopping
gddy shopping catalog search --category webHosting --limit 100 --json

It came back with a table of the three plans, their prices, and how many apps each one can publish. Then it stopped and said that when I picked one, it would create a checkout and show me the total, the agreement and the payment method before placing the order. That's the skill at work: it tells agents to confirm with you before any purchase and to link the terms you're agreeing to. Once you approve, the agent runs the same checkout, attach and publish commands from Part 1.

4. Keep going

From here, ask for whatever you need in plain language:

Set GREETING to "Hello from Claude" in production.

gddy hosting secret list --app-id NODEJS-abc123xyz --variant PUBLISH
gddy hosting secret create --app-id NODEJS-abc123xyz --variant PUBLISH --name GREETING --value "Hello from Claude"
gddy hosting app restart --app-id NODEJS-abc123xyz --variant PUBLISH
curl -sS https://abc123xyz.c38.airoapp.ai/

It knew to restart production so the app would load the new value, and it noted that preview still had the old greeting in case I wanted the two to match. "Ship my latest changes" and "show me the production errors from the last hour" work the same way.

Tip: Claude Code asks before it runs each shell command. To skip the prompts for this CLI only, allow Bash(gddy *) in your project's permission settings. Purchases still pause for your confirmation either way, because the skill asks before it buys anything.

To see the whole agent path in one take, here's Claude Code building a small site from an empty folder, deploying it to preview, buying a Web Hosting plan, publishing, and putting it on its own domain:

Good to know

  • The preview link is private. It opens only for you, signed in to your GoDaddy account. Publish when you want to share it.
  • Apps run on Node.js 22. Setting a different version in engines in package.json doesn't change it.
  • Preview and production share one database. Preview is for checking your code, not an isolated copy of your data. Be careful with migrations or test writes on preview.
  • Redeploy to the same app. Upload a new zip to your existing app ID rather than creating a new app for each change. A new app is a new URL and, once published, takes another plan slot.

Wrapping up

Whether you type the commands or your agent does, it's the same few steps: create an app, upload your code, check the preview, attach a plan, publish. No servers, no Dockerfile, no YAML. And because Node.js Hosting is included with Web Hosting, there's no meter running behind it.

To go further:

I'd love to hear what you ship. And if something in this walkthrough doesn't match what you see, tell us; that feedback goes straight to the team building it.

More articles like this

  • Gary Robert

    Gary Robert is a technical product lead for Hosting and has been with GoDaddy since 2014. During his time at GoDaddy, he has supported customers from several perspectives, including customer support, systems administration, and product management. Outside of work, he enjoys homelabbing and experimenting with servers, networking, home automation, and other technology.
    More Articles by Gary Robert