canonical: https://jentic.com/apis/krova.cloud/krova

# Krova Cloud API

The Krova Cloud API provisions and runs Cubes, Krova's virtual servers, inside a Space: create one from an OS image with a vcpu, ramGb, and diskGb sizing and an SSH public key, then power it off, wake it, restart it, or delete it. It also attaches custom domains with proxy settings and DNS record checks, forwards TCP ports, takes and restores snapshots, shares backups between Spaces, imports .cube archives, and sends signed webhooks for events such as cube.running or snapshot.created. Keys are scoped per Space and sent in the X-API-KEY header.

## For AI agents

Create, start, stop, and restart Krova Cubes, attach custom domains and TCP forwards, snapshot and restore them, and subscribe to lifecycle webhooks, all within the Space your API key belongs to.

## Scope

Does not handle managed databases, Kubernetes clusters, object storage, or domain registration. Use for provisioning and operating Krova Cubes, their domains, snapshots, and backups only.

## Capabilities

- Provision a Cube from an OS image with vcpu, ramGb, and diskGb resources, an sshPublicKey, an optional region, and a cloud-init userData script
- Power off, wake, or restart a Cube, and toggle terminationProtection so it cannot be deleted by mistake
- Attach a custom domain to a Cube with proxy options such as ipAllowList, corsConfig, and responseCompression, then read the DNS records it needs and their live status
- Forward TCP ports to a Cube with an optional IP whitelist and UDP support
- Snapshot a Cube, restore it from a snapshotId, and generate a presigned download URL for a backup archive
- Offer a backup to another Space and accept, decline, or cancel pending backup shares
- Register webhook endpoints for events like cube.created, cube.error, or backup.created and read the last 30 days of delivery history

## Use cases

### On-Demand Dev and Test Servers

A developer agent spins up a throwaway server for a branch or experiment. It reads available regions and OS images, creates a Cube with the required name, image, resources, and sshPublicKey, fetches SSH connection details for the new Cube, and powers it off or deletes it when the work is done. An Idempotency-Key header on the create call makes a retried request safe.

Example prompt: Call GET /regions and GET /images, then POST `/spaces/{spaceId}/cubes` with name 'feature-auth-test', image from the list, resources {vcpu: 2, ramGb: 4, diskGb: 40}, and an ssh-ed25519 sshPublicKey, then GET `/spaces/{spaceId}/cubes/{cubeId}/ssh`

### Publishing an App on a Custom Domain

Once an app runs on a Cube, the agent attaches a custom domain and port, reads the DNS records the mapping requires along with their live status, and tunes proxy settings such as securityHeadersMode or ipAllowList through the domain update operation. Raw TCP services such as databases or game servers get a TCP port forward instead.

Example prompt: Call POST `/spaces/{spaceId}/cubes/{cubeId}/domains` with domain 'app.example.com' and port 3000, then GET `/spaces/{spaceId}/cubes/{cubeId}/domains/{mappingId}/records` to list the DNS records to create

### Snapshot Before Risky Changes

Before an upgrade or migration, the agent snapshots the Cube, performs the change, and restores from the snapshotId if something breaks. Backups can be listed newest first, downloaded through a presigned URL, or offered to another Space, which accepts or declines the share.

Example prompt: Call POST `/spaces/{spaceId}/cubes/{cubeId}/snapshots` with name 'pre-upgrade', run the upgrade, and on failure call POST `/spaces/{spaceId}/cubes/{cubeId}/restore` with that snapshotId

### AI Agent Infrastructure Control via Jentic

An operations agent drives Krova Cloud through Jentic without handling the X-API-KEY itself. It searches by intent, receives the matching Cube operation with its input schema, and executes with the key injected at run time, so restarting a stuck server or reading webhook deliveries becomes one step in a larger runbook.

Example prompt: Search Jentic for 'restart a Krova Cube', load the POST `/spaces/{spaceId}/cubes/{cubeId}/restart` schema, and execute it for the target spaceId and cubeId

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/spaces/{spaceId}/cubes` | Create a Cube |
| GET | `/spaces/{spaceId}/cubes` | List Cubes in a Space |
| POST | `/spaces/{spaceId}/cubes/{cubeId}/restart` | Restart a running Cube |
| POST | `/spaces/{spaceId}/cubes/{cubeId}/power-off` | Power off a running Cube |
| POST | `/spaces/{spaceId}/cubes/{cubeId}/domains` | Attach a custom domain |
| POST | `/spaces/{spaceId}/cubes/{cubeId}/snapshots` | Create a snapshot |
| POST | `/spaces/{spaceId}/webhooks` | Create a webhook endpoint |
| GET | `/regions` | List regions with available capacity |

## Key resources

- **Cubes** — Create, read, update, delete, power off, wake, restart, and get SSH details for virtual servers
- **Domains and TCP mappings** — Attach custom domains with proxy settings, check DNS records, and forward TCP ports to a Cube
- **Snapshots and backups** — Snapshot and restore Cubes, list and download backups, and share them between Spaces
- **Imports** — Upload a .cube archive and finalize it into a new Cube
- **Webhooks** — Register endpoints for lifecycle and alert events and read delivery history
- **Catalog** — List regions, OS images, and pricing

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 44 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 62 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 21 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 70 / 100
- **View full report:** https://jentic.com/apis/krova.cloud/krova/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Krova Cloud by hand means sending a Space-scoped X-API-KEY, sending an Idempotency-Key on creates, and staying inside the mutating-call rate limit yourself. Through Jentic you install once, import Krova Cloud from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Krova Cloud puts both the Space id and the Cube id in the URL path (`/spaces/{spaceId}/cubes/{cubeId}/...`), so a rule can pin your agent to one Cube and the operations you pick. You choose that set, so destructive ones like Cube deletion or snapshot deletion are not included unless you add them.
- **Credential handling:** Your Krova Cloud key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a virtual server' or 'snapshot a Cube', and Jentic returns the matching Krova Cloud operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **DigitalOcean API** — Droplets, managed databases, Kubernetes, and networking
- **Hetzner Cloud API** — Cloud servers, volumes, networks, and firewalls
- **Cloudflare API** — DNS, CDN, and edge security

## FAQ

### What authentication does the Krova Cloud API use?

Per its OpenAPI spec, the Krova Cloud API uses the ApiKeyAuth scheme: an API key in the X-API-KEY header. Keys are scoped to one Space and inherit the permissions of the membership that created them. The regions, images, and pricing endpoints and the CLI device-login endpoints need no key. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at execution time.

### What are the rate limits for the Krova Cloud API?

The OpenAPI spec states that mutating POST and DELETE endpoints are rate-limited to 10 requests per 60 seconds per client IP. Reads are not given a limit in the spec, so pace bulk create or delete loops accordingly.

### Can I attach a custom domain to a Cube with the Krova Cloud API?

Yes. Send domain and port to the Cube's domains endpoint, with optional proxy settings such as securityHeadersMode, ipAllowList, ipDenyList, corsConfig, and responseCompression. The records endpoint for that mapping then lists the DNS records the domain needs and whether each is live, and the mapping can be updated or detached later.

### How do I restart a Cube through Jentic with the Krova Cloud API?

Search Jentic for 'restart a Krova Cube' and it returns the restart operation with its input schema. Execute POST `/spaces/{spaceId}/cubes/{cubeId}/restart` with the Space and Cube ids, and the key is injected at run time. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Is there a Krova Cloud MCP server?

You don't need an MCP server to give your agent the Krova Cloud API. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls it. Operations are discovered by intent on demand, so no extra server's tool definitions fill the agent's context.

### Can I limit what my agent is allowed to do with the Krova Cloud API?

Yes. Write a rule that allows only the power-off, wake, and restart operations plus GET on one cubeId, and the agent can recover that single server while every other Cube, snapshot, and domain stays untouched. Each call runs through your own instance, where it is logged.