Use Nextify from your AI assistant (MCP)

Two addresses

Address	Sign-in	Tools
`https://mcp.nextifynow.com/mcp`	Your Nextify account, or an API token	All tools
`https://mcp.nextifynow.com/public`	None	The public tools: plans, prices, images and the Knowledge Base

Both speak MCP over Streamable HTTP. Signing in uses your normal Nextify account, the same email and password as the portal: your assistant opens the Nextify sign-in page, and once you have signed in it acts as you. Clients that cannot sign in can send an API token instead.

Set up your assistant

Claude (claude.ai and Claude Desktop)

Open Settings → Connectors and choose Add custom connector.
Name it Nextify and enter the URL https://mcp.nextifynow.com/mcp.
Choose Connect and sign in with your Nextify account.
Turn the connector on for a chat from the chat's tools menu.

Claude Code

claude mcp add --transport http nextify https://mcp.nextifynow.com/mcp

Then run /mcp in Claude Code and choose nextify to sign in. With an API token instead:

claude mcp add --transport http nextify https://mcp.nextifynow.com/mcp \
  --header "Authorization: Bearer nxt_..."

ChatGPT

Open Settings → Apps & Connectors and turn on Developer mode (under Advanced settings).
Create a connector: name it Nextify, enter the URL https://mcp.nextifynow.com/mcp and choose OAuth as the authentication.
Sign in with your Nextify account when ChatGPT asks.

Cursor

Add this to ~/.cursor/mcp.json (every project) or .cursor/mcp.json (one project), then sign in when Cursor asks:

{
  "mcpServers": {
    "nextify": {
      "url": "https://mcp.nextifynow.com/mcp"
    }
  }
}

With an API token instead:

{
  "mcpServers": {
    "nextify": {
      "url": "https://mcp.nextifynow.com/mcp",
      "headers": {
        "Authorization": "Bearer nxt_..."
      }
    }
  }
}

VS Code

Add this to .vscode/mcp.json in your project, then sign in when VS Code starts the server:

{
  "servers": {
    "nextify": {
      "type": "http",
      "url": "https://mcp.nextifynow.com/mcp"
    }
  }
}

With an API token instead, without writing the token into the file (VS Code asks for it once and keeps it):

{
  "inputs": [
    {
      "type": "promptString",
      "id": "nextify-token",
      "description": "Nextify API token",
      "password": true
    }
  ],
  "servers": {
    "nextify": {
      "type": "http",
      "url": "https://mcp.nextifynow.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:nextify-token}"
      }
    }
  }
}

Windsurf

Add this to ~/.codeium/windsurf/mcp_config.json, then sign in when Windsurf asks:

{
  "mcpServers": {
    "nextify": {
      "serverUrl": "https://mcp.nextifynow.com/mcp"
    }
  }
}

With an API token instead:

{
  "mcpServers": {
    "nextify": {
      "serverUrl": "https://mcp.nextifynow.com/mcp",
      "headers": {
        "Authorization": "Bearer nxt_..."
      }
    }
  }
}

Other clients: an API token

Any MCP client that speaks Streamable HTTP can connect with an API token instead of signing in. Create one in the portal under Account → API tokens and send it on every request:

URL:     https://mcp.nextifynow.com/mcp
Header:  Authorization: Bearer nxt_...

A read-only token lets an assistant look without changing anything: the API answers only reads for it.
A token can have an expiry date. Revoking it in the portal takes effect on the next request.
A token is a password. Keep it out of files you share or commit.

More about tokens in the API documentation.

Without an account

The public address needs no sign-in and offers the public tools only: compare plans and prices, list the images, get a plan recommendation for a workload and search the Knowledge Base. For example, in Claude Code:

claude mcp add --transport http nextify-public https://mcp.nextifynow.com/public

Tools

Tool	What it does
Public, on both addresses
`list_regions`	The regions, with their code and status.
`list_plans`	The machine plans offered in a region, with vCPU, memory, disk and price.
`get_pricing`	Prices for everything besides plans: block storage, snapshots, extra IPs, S3, transfer and load balancers.
`list_images`	The operating system images you can create an instance from, optionally only those that boot on a given plan.
`recommend_plan`	Describe what you want to run; get the plans from the live catalog that fit it best.
`get_docs`	Search and read the Knowledge Base.
Your account, signed in
`get_account`	Your account and who you are signed in as.
`list_instances`	Your instances and their status.
`get_instance`	One instance: plan, region, addresses and status.
`create_instance`	Create an instance from a plan, an image and your SSH keys, optionally with a startup script or an app from a Git repository, labels and encrypted secrets. Billed to your account.
`get_setup_log`	Whether an instance's startup script or app deploy finished, with its output.
`redeploy_instance`	Pull, build and restart the app of an instance created from a Git repository.
`list_resize_options`	The larger and smaller plans an instance can move to, what applies live and what needs a restart, and whether its disk can grow.
`resize_instance`	Move an instance to another plan of the same line after you confirm; growing the disk is permanent (a disk cannot shrink), so keep it to keep smaller plans available.
`set_instance_power`	Start or stop an instance. A stopped instance is not billed for compute.
`delete_instance`	Delete an instance and its boot disk. This cannot be undone; it needs the instance's exact name.
`get_job`	Follow a background job (a create, a resize, a redeploy, a power change or a delete) to its end.
`list_ssh_keys`	The SSH keys on your account.
`add_ssh_key`	Add a public SSH key to your account.
`list_deploy_keys`	The deploy keys on your account, for cloning private Git repositories.
`create_deploy_key`	Create a deploy key and get its public key, to add to a private repository as a read-only deploy key.
`list_private_networks`	Your private networks.
`list_load_balancers`	Your load balancers, their status and public IP.
`create_load_balancer`	Create a load balancer in front of a pool of your instances (the port they listen on, e.g. 80). Billed to your account.
`add_domain`	Add a domain to a load balancer that has a pool of instances, with an automatic Let's Encrypt certificate; returns the DNS record to create.
`list_domains`	A load balancer's domains: whether DNS points at it yet and the certificate's state.
`get_billing_summary`	Your usage and charges so far in the current billing period.

Costs and safety

Creating instances and load balancers costs money. They are billed to your account and charged to its card at the published prices, by the hour, exactly as if you had created them in the portal. Renting needs a card on file.
Your assistant acts as you, within your account's limits. Most assistants ask before they use a tool that changes something: read what it is about to create or delete before you allow it.
Deleting an instance deletes its boot disk too. It cannot be undone. The assistant must repeat the instance's exact name, or nothing is deleted.
Sign-in uses your normal Nextify account; there is no separate login for assistants. To cut off a client that uses a token, revoke the token in the portal.

Load balancers and domains

A load balancer sends traffic to a pool of your instances. For a website, ask the assistant to create the load balancer with your instances and the port they listen on (usually 80), then to add your domain. add_domain needs that pool: on a load balancer without one it answers no_http_pool. It returns the A record to create at your DNS provider; the certificate follows once the record resolves.

Things to ask

"Which plan fits a PostgreSQL database with 8 GB of memory, and what does it cost per month?"
"Create a Shared vCPU instance called web-1 with my SSH key, and tell me its IP address when it is running."
"Put web-1 and web-2 behind a load balancer on port 80 and add example.com with a certificate."
"What have I used so far this billing period?"

More in the Knowledge Base: Use Nextify from AI assistants (MCP).

For language models, a plain-text summary of Nextify with its current prices is at /llms.txt.