Novita AI

https://docs.novita.ai/
Admin
Novita AI provides cloud infrastructure for running AI models with scalable model inference APIs,...
Tokens:848,006
Snippets:5,746
Trust Score:8.9
Update:2 days ago
Show doc for...
Tokens:
Raw
### Get started with generated Python files

Source: https://docs.novita.ai/guides/sandbox-cli-template-migrate

Commands to install the SDK and run development and production builds after migrating to Python.

```bash
pip install novita-sandbox
python build_dev.py    # development build
python build_prod.py   # production build
```

--------------------------------

### Get started with generated TypeScript files

Source: https://docs.novita.ai/guides/sandbox-cli-template-migrate

Commands to install the SDK and run development and production builds after migrating to TypeScript.

```bash
npm install novita-sandbox
npx tsx build.dev.ts   # development build
npx tsx build.prod.ts  # production build
```

--------------------------------

### Go example

Source: https://docs.novita.ai/api-reference/gpu-instance-list-network-storage

Uses net/http to GET the network storage list and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpu-instance/openapi/v1/networkstorages/list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Content-Type", "<content-type>")
	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Go example

Source: https://docs.novita.ai/api-reference/gpus-v2-list-image

Uses net/http to GET the images endpoint and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpus/v2/images"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Go example

Source: https://docs.novita.ai/api-reference/gpus-v2-list-templates

Uses net/http to send a GET request to the templates endpoint and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpus/v2/templates"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Go example for listing CPU products

Source: https://docs.novita.ai/api-reference/gpu-instance-list-cpu-products

Uses net/http to send a GET request and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpu-instance/openapi/v1/cpu/products"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Content-Type", "<content-type>")
	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Install Python SDK with pip

Source: https://docs.novita.ai/guides/model-apis-sdks

Use this command to install the Novita AI Python SDK via pip. After installation, visit the quick start guide at https://github.com/novitalabs/python-sdk.

```bash
pip install novita-client
```

--------------------------------

### Start Instance with Go

Source: https://docs.novita.ai/api-reference/gpu-instance-start-instance

Uses net/http to send a POST request with the instanceId. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpu-instance/openapi/v1/gpu/instance/start"

	payload := strings.NewReader("{\n  \"instanceId\": \"<string>\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "<content-type>")
	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Install JavaScript SDK with npm

Source: https://docs.novita.ai/guides/model-apis-sdks

Use this command to install the Novita AI JavaScript SDK via npm. After installation, visit the quick start guide at https://github.com/novitalabs/javascript-sdk.

```bash
npm i novita-sdk
```

--------------------------------

### Web server example (Python)

Source: https://docs.novita.ai/guides/sandbox-pause-resume

Python equivalent: creates a sandbox with auto-resume, runs a background HTTP server, and prints the preview URL.

```python
from novita_sandbox import Novita

novita = Novita()
sandbox = novita.sandbox.create(
    timeout=5 * 60,
    lifecycle={
        'on_timeout': 'pause',
        'auto_resume': True,
    },
)

sandbox.commands.run('python3 -m http.server 3000', background=True)
host = sandbox.get_host(3000)
print(f'Preview URL: https://{host}')
```

--------------------------------

### novitaclaw services setup

Source: https://docs.novita.ai/guides/novitaclaw-commands

Installs and starts Web Terminal and File Manager on an existing sandbox. Use this to add services to older sandboxes that were launched before these services were included.

```APIDOC
## novitaclaw services setup

### Description
Installs and starts Web Terminal and File Manager on an existing sandbox. Use this to add services to older sandboxes that were launched before these services were included.

### Method
CLI

### Endpoint
novitaclaw services setup

### Parameters
#### Options
- **--api-key** (string) - Required - Novita API key

### Request Example
```
novitaclaw services setup --api-key YOUR_API_KEY
```

### Response
No response body specified.
```

--------------------------------

### Web server example (JavaScript/TypeScript)

Source: https://docs.novita.ai/guides/sandbox-pause-resume

Creates a sandbox with auto-resume, starts a background HTTP server on port 3000, and prints a preview URL.

```javascript
import { Novita } from 'novita-sandbox'

const novita = new Novita()
const sandbox = await novita.sandbox.create({
  timeoutMs: 5 * 60 * 1000,
  lifecycle: {
    onTimeout: 'pause',
    autoResume: true,
  },
})

await sandbox.commands.run('python3 -m http.server 3000', { background: true })
const host = sandbox.getHost(3000)
console.log(`Preview URL: https://${host}`)
```

--------------------------------

### Go: Start Instance with net/http

Source: https://docs.novita.ai/api-reference/gpus-v2-start-instance

Uses the standard net/http package to send a PUT request to start an instance. Prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpus/v2/instances/{instance_id}/start"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Get Virtual Desktop Stream VNC URL (TypeScript)

Source: https://docs.novita.ai/guides/sandbox-integrations-desktop

TypeScript example using the Novita SDK to create a desktop, start streaming, and retrieve interactive and view-only VNC URLs. Includes signal handlers for cleanup.

```TypeScript
// demo.ts implementation
import { Novita } from 'novita-sandbox'

async function main() {
  const novita = new Novita({ apiKey: process.env.NOVITA_API_KEY })

  // Initialize virtual desktop sandbox instance
  const desktop = await novita.desktop.create({ timeoutMs: 3_600_000 })

  // Activate desktop streaming service
  await desktop.stream.start()

  // Retrieve interactive VNC endpoint URL
  const url = desktop.stream.getUrl()
  console.log(url)

  // Expected output format:
  // Browser-accessible URL for interactive virtual desktop session. Suitable for application integration.
  // https://6080-ik0n7lc3j0dvqd4jxy6g7.us-phx-1.sandbox.novita.ai/vnc.html?autoconnect=true&resize=scale

  // Retrieve read-only VNC endpoint URL (interaction disabled)
  const urlDisabledInteraction = desktop.stream.getUrl({ viewOnly: true })
  console.log(urlDisabledInteraction)
  // Expected output format:
  // Browser-accessible URL for view-only virtual desktop session (non-interactive mode). Suitable for monitoring applications.
  // https://6080-ik0n7lc3j0dvqd4jxy6g7.us-phx-1.sandbox.novita.ai/vnc.html?autoconnect=true&view_only=true&resize=scale

  // Keep the program running
  console.log("Desktop stream started, press Ctrl+C to stop the program...")
  const interval = setInterval(() => {}, 1000)

  // Register interrupt signal handlers for resource cleanup
  let isCleaning = false
  const cleanup = async () => {
    if (isCleaning) return
    isCleaning = true

    console.log("\nProgram interrupted, cleaning up resources...")
    clearInterval(interval)
    try {
      await desktop.stream.stop() // Terminate streaming service
      await desktop.kill()        // Deallocate sandbox instance
    } catch (err) {
      console.error("Error cleaning up resources:", err)
    }
    process.exit(0)
  }

  process.on('SIGINT', cleanup)
  process.on('SIGTERM', cleanup)
}

main().catch(console.error)
```

--------------------------------

### Create Sandbox and Run Commands (Python)

Source: https://docs.novita.ai/guides/sandbox-legacy-e2b-compatible

Example showing how to create a sandbox through the SDK and run specified commands.

```python
from novita_sandbox.code_interpreter import Sandbox

sbx = Sandbox.create()
execution = sbx.commands.run('ls -l')
print(execution)

sbx.kill()
```

--------------------------------

### Get Virtual Desktop Stream VNC URL (Python)

Source: https://docs.novita.ai/guides/sandbox-integrations-desktop

Python example using the Novita SDK to create a desktop, start streaming, and retrieve interactive and view-only VNC URLs. Includes keyboard interrupt handling for graceful shutdown.

```Python
# demo.py implementation
import os
import time

from novita_sandbox import Novita

novita = Novita(api_key=os.environ["NOVITA_API_KEY"])

# Initialize virtual desktop sandbox instance
desktop = novita.desktop.create(timeout=3600)

# Activate desktop streaming service
desktop.stream.start()

# Retrieve interactive VNC endpoint URL
url = desktop.stream.get_url()
print(url)
# Expected output format:
# Browser-accessible URL for interactive virtual desktop session. Suitable for application integration.
# https://6080-ik0n7lc3j0dvqd4jxy6g7.us-phx-1.sandbox.novita.ai/vnc.html?autoconnect=true&resize=scale

# Retrieve read-only VNC endpoint URL (interaction disabled)
url_readonly = desktop.stream.get_url(view_only=True)
print(url_readonly)
# Expected output format:
# Browser-accessible URL for view-only virtual desktop session (non-interactive mode). Suitable for monitoring applications.
# https://6080-ik0n7lc3j0dvqd4jxy6g7.us-phx-1.sandbox.novita.ai/vnc.html?autoconnect=true&view_only=true&resize=scale

# Implement keyboard interrupt handling for graceful shutdown
try:
    print("Desktop stream started, press Ctrl+C to stop the program...")
    while True:
        time.sleep(0.1)
except KeyboardInterrupt:
    print("\nProgram interrupted, cleaning up resources...")

# Execute resource deallocation procedures
desktop.stream.stop()  # Terminate streaming service
desktop.kill()        # Deallocate sandbox instance
```

--------------------------------

### Example coding task for Codex

Source: https://docs.novita.ai/guides/codex

An example prompt to give Codex after it starts.

```text
Read this project and summarize the main modules.
```

--------------------------------

### Install and run CLI with npx (Option 1)

Source: https://docs.novita.ai/guides/sandbox-agent-runtime-installation

Install the beta CLI locally in your project directory using npm, then run it with npx. This avoids polluting your global environment with the beta version. Includes authentication and agent configuration commands.

```bash
# Install the latest beta version CLI
npm install novita-sandbox-cli@beta

# First, complete authentication
npx novita auth login

# Run agent configure command to configure your Agent
npx novita agent configure
```

--------------------------------

### Run main.py with python

Source: https://docs.novita.ai/guides/sandbox-your-first-agent-sandbox

Command to execute the Python example file main.py.

```bash
python main.py
```

--------------------------------

### 200 response example for Get Endpoint

Source: https://docs.novita.ai/api-reference/gpus-v2-get-endpoint

Example JSON response returned by the Get Endpoint API when the request succeeds. Contains endpoint configuration, status, worker details, and health check information.

```json
{
  "id": "endpoint-id",
  "type": "sync",
  "name": "example-endpoint",
  "app_name": "example-app",
  "status": {
    "status": "running",
    "error": "",
    "message": ""
  },
  "url": "https://endpoint.example.com/endpoint-id",
  "product_id": "<string>",
  "worker_config": {
    "min_replicas": 0,
    "max_replicas": 2,
    "idle_timeout": 300,
    "max_concurrent_per_worker": 10,
    "gpu_num": 1,
    "rootfs_size_gb": 20,
    "min_cuda_version": "12.4",
    "request_timeout": 60
  },
  "policy": {
    "type": "queue",
    "value": 100
  },
  "image": "registry.example.com/namespace/image:tag",
  "registry_auth_id": "registry-auth-id",
  "entrypoint": "",
  "command": "cargo run",
  "volumes": [
    {
      "id": "storage-id",
      "type": "network",
      "mount_point": "/data"
    }
  ],
  "envs": [
    {
      "key": "ENV_NAME",
      "value": "ENV_VALUE"
    }
  ],
  "ports": [
    8080
  ],
  "workers": [
    {
      "id": "worker-id",
      "status": {
        "status": "ready",
        "error": "",
        "message": ""
      },
      "log": "https://logs.example.com/worker-id",
      "health": true,
      "drain": false
    }
  ],
  "health_check": {
    "path": "/healthz",
    "port": 8080
  },
  "region_id": "region-id",
  "member_id": "member-id",
  "owner_id": "550e8400-e29b-41d4-a716-446655440000",
  "created_at": 1710000000
}
```

--------------------------------

### novita agent launch examples

Source: https://docs.novita.ai/guides/sandbox-cli-agent-launch

Examples of deploying with the project configuration, validating with `--dry-run`, and updating an existing template with `--update-existing`.

```bash
# Deploy using the project configuration
novita agent launch

# Validate everything without deploying
novita agent launch --dry-run

# Update the existing template instead of creating a new one
novita agent launch --update-existing
```

--------------------------------

### 200 Response: Get Instance

Source: https://docs.novita.ai/api-reference/gpus-v2-get-instance

Example JSON response returned by the Get Instance endpoint when the request succeeds.

```json
{
  "id": "ca338f12f3",
  "name": "example-instance",
  "type": "gpu",
  "product_id": "product-id",
  "image": "registry.example.com/namespace/image:tag",
  "registry_auth_id": "registry-auth-id",
  "entrypoint": "",
  "command": "",
  "billing": {
    "mode": "prepaid",
    "prepaid": {
      "months": 1,
      "end_time": 1714464000,
      "auto_renew": {
        "enabled": true,
        "months": 1,
        "status": "active"
      }
    }
  },
  "envs": [
    {
      "key": "ENV_NAME",
      "value": "ENV_VALUE"
    }
  ],
  "ports": [
    {
      "port": 8080,
      "protocol": "tcp",
      "endpoint": "http://1.2.3.4:8080"
    }
  ],
  "resource_specs": {
    "rootfs_size_gb": 20,
    "gpu_num": 1,
    "cpu_num": 8,
    "memory_gb": 32,
    "gpu_ids": [
      0
    ]
  },
  "network": {
    "id": "vpc-550e8400-e29b-41d4-a716-446655440000",
    "ip": "10.2.1.1"
  },
  "volumes": [
    {
      "type": "network",
      "id": "network-storage-id",
      "mount_point": "/data"
    }
  ],
  "region": "region-id",
  "tools": {
    "jupyter": {
      "endpoint": "https://jupyter.example.com/instance/ca338f12f3",
      "enabled": true,
      "port": 8888
    },
    "ssh": {
      "command": "ssh -p 51039 root@proxy.cn-south-nas-1.gpu-instance.novita.ai",
      "password": "xxx",
      "username": "xxx"
    },
    "web_terminal": {
      "endpoint": "wss://terminal.example.com/instance/ca338f12f3",
      "enabled": true,
      "username": "root",
      "password": "xxx"
    },
    "log": {
      "instance_endpoint": "https://log.example.com/system/ca338f12f3",
      "system_endpoint": "https://log.example.com/instance/ca338f12f3"
    }
  },
  "auto_migrate": {
    "enabled": false,
    "include_system_disk": false
  },
  "status": {
    "status": "running",
    "error": "",
    "message": ""
  },
  "pricing": {
    "instance_price": 100,
    "instance_base_price": 120,
    "rootfs_storage_price": 10,
    "prepaid": {
      "monthly_price": [
        {
          "price": 1000,
          "base_price": 1200,
          "month": 1,
          "price_precision": 2,
          "month_spec_id": "spec-1m"
        }
      ]
    },
    "spot": {
      "spot_status": "<string>",
      "spot_reclaim_time": 123
    }
  },
  "created_at": 1714464000,
  "last_started_at": 1714467600,
  "last_stopped_at": 0,
  "member_id": "member-id",
  "owner_id": "550e8400-e29b-41d4-a716-446655440000",
  "region_version": "v1.0"
}
```

--------------------------------

### Get Network with Java Unirest

Source: https://docs.novita.ai/api-reference/gpus-v2-get-vpc

Java example using Unirest to GET network details. Sends a GET request with the authorization header and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.novita.ai/gpus/v2/networks/{network_id}")
  .header("Authorization", "<authorization>")
  .asString();
```

--------------------------------

### Set up services on sandbox

Source: https://docs.novita.ai/guides/novitaclaw-commands

Installs and starts Web Terminal and File Manager on an existing sandbox. Use this to add services to older sandboxes that were launched before these services were included. Requires the --api-key option.

```bash
novitaclaw services setup --api-key YOUR_API_KEY
```

--------------------------------

### Get Network with Ruby

Source: https://docs.novita.ai/api-reference/gpus-v2-get-vpc

Ruby example using net/http to GET network details. Sets up an HTTPS connection, sends a GET request with the authorization header, and prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.novita.ai/gpus/v2/networks/{network_id}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### Create Sandbox and Run Commands (JavaScript/TypeScript)

Source: https://docs.novita.ai/guides/sandbox-legacy-e2b-compatible

Example showing how to create a sandbox through the SDK and run specified commands.

```javascript
import { Sandbox } from 'novita-sandbox/code-interpreter'

const sbx = await Sandbox.create()
const execution = await sbx.commands.run('ls -l')
console.log(execution)

await sbx.kill()
```

--------------------------------

### Go GET Endpoint request

Source: https://docs.novita.ai/api-reference/serverless-get-endpoint

Go example using net/http to call the Get Endpoint API. Prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpu-instance/openapi/v1/endpoint"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Content-Type", "<content-type>")
	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### List VPC Networks with Java (Unirest)

Source: https://docs.novita.ai/api-reference/gpu-instance-list-vpc

Java example using Unirest to send a GET request and get the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.novita.ai/gpu-instance/openapi/v1/networks")
  .header("Content-Type", "<content-type>")
  .header("Authorization", "<authorization>")
  .asString();
```

--------------------------------

### Run the setup.sh script

Source: https://docs.novita.ai/guides/docsgpt

Executes the interactive setup script for DocsGPT. It offers options for using the public API, running locally, connecting to a local inference engine, or using a cloud API provider, and configures the .env file accordingly.

```bash
./setup.sh
```

--------------------------------

### Install novi with pinned version

Source: https://docs.novita.ai/guides/novita-connect

Installs a specific release of `novi` by setting the `NOVI_VERSION` environment variable. This example pins version 0.3.0.

```bash
curl -fsSL https://novita.ai/connect/install.sh | NOVI_VERSION=0.3.0 sh
```

--------------------------------

### Create .env from .env.example

Source: https://docs.novita.ai/guides/sandbox-coding-agent-openai-agents-api

Copies the repository's .env.example to .env so you can fill in the required environment variables (NOVITA_API_KEY, OPENAI_API_KEY, OPENAI_EXECUTOR_API_KEY, OPENAI_AGENT_ID, OPENAI_WEBHOOK_SECRET).

```bash
cp .env.example .env
```

--------------------------------

### Ruby GET Endpoint request

Source: https://docs.novita.ai/api-reference/serverless-get-endpoint

Ruby example using Net::HTTP to call the Get Endpoint API. Prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.novita.ai/gpu-instance/openapi/v1/endpoint")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = '<content-type>'
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### Java Unirest GET Endpoint request

Source: https://docs.novita.ai/api-reference/serverless-get-endpoint

Java example using Unirest to call the Get Endpoint API. Returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.novita.ai/gpu-instance/openapi/v1/endpoint")
  .header("Content-Type", "<content-type>")
  .header("Authorization", "<authorization>")
  .asString();
```

--------------------------------

### Run OWL with Novita AI

Source: https://docs.novita.ai/guides/owl

Execute the example script to start OWL and run a task using Novita AI.

```bash
python examples/run_novita_ai.py
```

--------------------------------

### Install packages with pip_install, npm_install, bun_install, apt_install helpers (Python)

Source: https://docs.novita.ai/guides/sandbox-template-authoring

Shows usage of pip_install, npm_install, bun_install, and apt_install helpers. Each accepts a single package name or a list; omitting packages installs from the current project. Options include g, dev, no_install_recommends.

```python
template.pip_install('numpy')
template.pip_install(['pandas', 'scikit-learn'])
template.pip_install('numpy', g=False)
template.pip_install()

template.npm_install('express')
template.npm_install('tsx', g=True)
template.npm_install('typescript', dev=True)

template.bun_install(['lodash', 'axios'])

template.apt_install(['git', 'curl', 'wget'])
template.apt_install(['vim'], no_install_recommends=True)
```

--------------------------------

### PHP GET Endpoint request

Source: https://docs.novita.ai/api-reference/serverless-get-endpoint

PHP example using cURL to call the Get Endpoint API. Outputs the response or a cURL error.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.novita.ai/gpu-instance/openapi/v1/endpoint",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>",
    "Content-Type: <content-type>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Python GET Endpoint request

Source: https://docs.novita.ai/api-reference/serverless-get-endpoint

Python example using the requests library to call the Get Endpoint API. Prints the response text.

```python
import requests

url = "https://api.novita.ai/gpu-instance/openapi/v1/endpoint"

headers = {
    "Content-Type": "<content-type>",
    "Authorization": "<authorization>"
}

response = requests.get(url, headers=headers)

print(response.text)
```

--------------------------------

### Set up OWL environment variables

Source: https://docs.novita.ai/guides/owl

Copy the environment template to create the .env file, then add your Novita API key.

```bash
cd owl
cp .env_template .env
```

--------------------------------

### Install packages with pip, npm, bun, apt helpers (JavaScript/TypeScript)

Source: https://docs.novita.ai/guides/sandbox-template-authoring

Shows usage of pipInstall, npmInstall, bunInstall, and aptInstall helpers. Each accepts a single package name or a list; omitting packages installs from the current project. Options include g, dev, noInstallRecommends.

```javascript
template.pipInstall('numpy')
template.pipInstall(['pandas', 'scikit-learn'])
template.pipInstall('numpy', { g: false })
template.pipInstall()

template.npmInstall('express')
template.npmInstall('tsx', { g: true })
template.npmInstall('typescript', { dev: true })

template.bunInstall(['lodash', 'axios'])

template.aptInstall(['git', 'curl', 'wget'])
template.aptInstall(['vim'], { noInstallRecommends: true })
```

--------------------------------

### JavaScript fetch GET Endpoint request

Source: https://docs.novita.ai/api-reference/serverless-get-endpoint

JavaScript example using fetch to call the Get Endpoint API. Logs the JSON response or error.

```javascript
const options = {
  method: 'GET',
  headers: {'Content-Type': '<content-type>', Authorization: '<authorization>'}
};

fetch('https://api.novita.ai/gpu-instance/openapi/v1/endpoint', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### POST /

Source: https://docs.novita.ai/api-reference/gpus-v2-create-instance

Creates a new instance with the specified configuration. The request body must include name, product_id, image, billing, and resource. Optional fields allow customization of instance type, environment variables, ports, volumes, and more.

```APIDOC
## POST /

### Description
Creates a new instance with the specified configuration.

### Method
POST

### Endpoint
/

### Parameters
#### Request Body
- **name** (string) - Required - Instance name. Length: 1-255 characters. Example: `"example-instance"`
- **product_id** (string) - Required - Product ID. Example: `"product-id"`
- **image** (string) - Required - Image address. Length: 1-500 characters. Example: `"registry.example.com/namespace/image:tag"`
- **billing** (object) - Required - Billing configuration.
- **resource** (object) - Required - Resource configuration.
- **type** (enum<string>) - Optional - Instance type. Allowed values: `gpu`, `cpu`. Default: `gpu`.
- **registry_auth_id** (string) - Optional - Saved registry authentication ID. Length: 0-255 characters. Example: `"registry-auth-id"`
- **entrypoint** (string) - Optional - Container entrypoint. Example: `""`
- **command** (string) - Optional - Container startup command. Example: `""`
- **envs** (object[]) - Optional - Environment variable list.
- **ports** (object[]) - Optional - Exposed port list.
- **network** (object) - Optional - VPC network configuration.
- **volumes** (object[]) - Optional - Data disk / network storage mounts.
- **candidate_regions** (string[]) - Optional - Candidate regions for scheduling. The instance is finally scheduled to one of them. Example: `["region-id"]`
- **tools** (object) - Optional - Instance tool configuration. Currently only Jupyter is supported.
- **auto_migrate** (object) - Optional - Auto-migrate configuration.

### Response
#### Success Response (200)
- **id** (string) - ID of the created instance. Example: `"ca338f12f3"`

#### Response Example
{
  "id": "ca338f12f3"
}
```

--------------------------------

### Get Network with Go

Source: https://docs.novita.ai/api-reference/gpus-v2-get-vpc

Go example using net/http to GET network details. Creates a request with the authorization header and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.novita.ai/gpus/v2/networks/{network_id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Set up Python environment and install OpenAI Agents SDK

Source: https://docs.novita.ai/guides/openai-agents-sdk

Creates a virtual environment and installs the OpenAI Agents SDK version 0.0.7. Run these commands in your terminal before proceeding.

```bash
python -m venv env
source env/bin/activate
pip install openai-agents==0.0.7
```

--------------------------------

### Get Network with PHP cURL

Source: https://docs.novita.ai/api-reference/gpus-v2-get-vpc

PHP example using cURL to GET network details. Sets the authorization header and outputs the response or an error.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.novita.ai/gpus/v2/networks/{network_id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Python: Start Instance with requests

Source: https://docs.novita.ai/api-reference/gpus-v2-start-instance

Uses the requests library to send a PUT request to start an instance. Requires the requests package and an API key.

```python
import requests

url = "https://api.novita.ai/gpus/v2/instances/{instance_id}/start"

headers = {"Authorization": "<authorization>"}

response = requests.put(url, headers=headers)

print(response.text)
```

--------------------------------

### Get Network with JavaScript fetch

Source: https://docs.novita.ai/api-reference/gpus-v2-get-vpc

JavaScript example using fetch to GET network details. Handles the response as JSON and logs it, with error handling.

```javascript
const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

fetch('https://api.novita.ai/gpus/v2/networks/{network_id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```
Tokens:
Raw