Introducing Huddle01 Cloud APIs

Introducing Huddle01 Cloud APIs

Starting Today, Huddle01 Cloud is fully programmable.
Cloud APIs let you control your infrastructure from code, wire it into CI pipelines and build your own virtual plane on top of ours.

You already had a fast control panel. Now you get an API surface that matches it.

If you want to jump straight into the technical details, you can head to:

• Docs home: https://console.huddle01.com/docs

• Cloud APIs overview and reference: https://console.huddle01.com/docs/cloud-apis

What you can do with Cloud APIs

Cloud APIs give you programmatic access to the same primitives you use in the dashboard:

• Instances - create, list, resize and delete virtual machines

• Keypairs - manage SSH keys for secure access

• Security groups - control inbound and outbound traffic

• Flavors - choose the right CPU and RAM shapes for your workloads

• Images - pick base images for your instances

All of this is scoped to your workspace, which means you can safely integrate Huddle01 Cloud into team workflows and automation without sharing personal credentials.

Typical things you can build on top:

• CI pipeline steps that spin up short lived environments per pull request

• Internal tools that let your team request and manage VMs without ever visiting the dashboard

• Auto scaling workers or cron fleets controlled from your own scheduler

• Custom observability or billing views fed directly by our API

For a detailed list of resources and endpoints you can always refer to the Cloud APIs docs

API design at a glance

The API has a simple contract so you can get productive quickly.

• Base URL

  <https://cloud.huddleapis.com/api/v1>

• Authentication

  Every request includes your workspace secret in a header:

  x-api-key: <your-key>

• Regions and pagination

  • Most list endpoints accept a region query parameter like eu2

  • Pagination is handled with limit and offset query parameters

    limit is capped at 20 so you do not accidentally pull huge payloads.

You can find request and response schemas for each resource in the Cloud API reference

Step 1 - Generate an API key

To keep things secure, all Cloud API access is done using API keys that are scoped to a workspace.

You can create and manage API keys from the dashboard:

1. Sign in at https://cloud.huddle01.com and select the workspace you want to automate

2. Open Usage & Billing > API Keys

3. Click Create API Key, optionally give it a name and confirm

4. Copy the secret immediately and save it in your secret manager

5. Use this secret as the x-api-key header on every Cloud API request

You can have up to 5 active API keys per workspace, which gives you room to separate keys by environment or usage while still being easy to manage.

API key walkthrough

Watch the short guide below to generate your first API key from the dashboard.

Step 2 - Make your first request

Once you have your API key in a safe place, you can hit the API in a single command.

Here is a minimal example in curl that lists your instances in the eu2 region:

curl -X GET \\
  "<https://cloud.huddleapis.com/api/v1/instances?region=eu2&limit=10>" \\
  -H "x-api-key: $HUDDLE_API_KEY" \\
  -H "Accept: application/json"

Step 3 - Wire it into your workflow

Once the basics are working, the real value of Cloud APIs comes from integration.

A few simple patterns:

Preview environments per pull request

• CI generates a branch specific VM using the Instances API

• Your app is deployed on that VM

• A comment is posted back on the pull request with the preview URL

• When the branch is merged or closed, CI deletes the instance

Internal self service for engineers

• A small internal dashboard that talks to the Cloud APIs

• Engineers request VMs with pre selected flavors and regions

• Security groups and keypairs are applied automatically

• The platform team still keeps central visibility through the Huddle01 Cloud dashboard

Scheduled or batch workloads

• A scheduler creates workers only when a job queue crosses a threshold

• Workers process jobs and exit when the queue is empty

• Cloud APIs are used to create and destroy these worker instances efficiently

For more advanced patterns, you can keep an eye on the examples section inside

Security and key management

Because API keys are powerful, treat them as secrets:

• Never commit keys to Git or share them in chats

• Store them in a secret manager that your CI and services can access

• Rotate keys regularly

The recommended pattern is:

1. Create a new key

2. Update all clients to use the new key

3. Revoke the old key from the dashboard

Keys are only shown once when created, so if you lose a key you should revoke it and create a new one.

You can always review key management details in the API keys section of the docs and dashboard.

What's next

Cloud APIs are the foundation for a more programmable Huddle01 Cloud.

We are already working on:

• Deeper networking controls through APIs

• Better metrics and usage endpoints that you can plug into your own observability stack

• More first class examples and templates for popular stacks and CI providers

• Bringing in APIs to launch Docker and Kubernetes Clusters

If there is an endpoint or capability you want to see, tell us. The best ideas usually come from people trying to build something slightly unreasonable.

For a full and always up to date view of what is available, check the docs

Try Cloud APIs with free credits

If you are new to Huddle01 Cloud, this is the right moment to try it in a serious way.

• Sign up with your work email

• Instantly receive $250 in cloud credits to your account

• Use those credits to create workspaces, generate API keys and spin up your first workloads through the API

Then:

1. Read the quick overview here

2. Deep dive into the Cloud APIs section here

3. Generate a key, run the curl example above and plug Cloud APIs into something real, a CI job, a small internal tool or a one off script that saves your team time every week

This is how Huddle01 Cloud is meant to be used, as a fast, fair priced cloud that you can fully control from code and understand clearly through the docs that sit right next to it.