API examples

These examples show the same flow in multiple languages: login via POST /v1/login, then call a protected endpoint (we’ll use GET /v1/sites).

PHP (cURL)

<?php

$baseUrl = "https://api.rocket.net";
$username = getenv("ROCKETNET_USERNAME");
$password = getenv("ROCKETNET_PASSWORD");

if (!$username || !$password) {
  fwrite(STDERR, "Set ROCKETNET_USERNAME and ROCKETNET_PASSWORD\n");
  exit(1);
}

function httpJson(string $method, string $url, ?array $jsonBody = null, array $headers = []): array {
  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
  $allHeaders = array_merge(["Accept: application/json"], $headers);
  if ($jsonBody !== null) {
    $payload = json_encode($jsonBody);
    $allHeaders[] = "Content-Type: application/json";
    curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
  }
  curl_setopt($ch, CURLOPT_HTTPHEADER, $allHeaders);

  $resp = curl_exec($ch);
  if ($resp === false) {
    throw new RuntimeException("cURL error: " . curl_error($ch));
  }
  $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  curl_close($ch);

  $data = json_decode($resp, true);
  if (!is_array($data)) {
    throw new RuntimeException("Unexpected response (HTTP $status): " . $resp);
  }

  return ["status" => $status, "json" => $data];
}

// 1) Login -> JWT
$login = httpJson("POST", "$baseUrl/v1/login", [
  "username" => $username,
  "password" => $password,
]);
if ($login["status"] !== 200 || empty($login["json"]["token"])) {
  throw new RuntimeException("Login failed: " . json_encode($login["json"]));
}
$token = $login["json"]["token"];

// 2) Call an authenticated endpoint
$sites = httpJson("GET", "$baseUrl/v1/sites", null, [
  "Authorization: Bearer $token",
]);
	echo json_encode($sites["json"], JSON_PRETTY_PRINT) . "\n";

Python (httpx)

import os

import httpx


BASE_URL = "https://api.rocket.net"


def get_env(name: str) -> str:
    value = os.environ.get(name)
    if not value:
        raise SystemExit(f"Missing env var: {name}")
    return value


def login(client: httpx.Client, username: str, password: str) -> str:
    resp = client.post(
        f"{BASE_URL}/v1/login",
        json={"username": username, "password": password},
        headers={"Accept": "application/json"},
        timeout=30,
    )
    resp.raise_for_status()
    data = resp.json()
    token = data.get("token")
    if not token:
        raise RuntimeError(f"Login response missing token: {data}")
    return token


def list_sites(client: httpx.Client, token: str) -> dict:
    resp = client.get(
        f"{BASE_URL}/v1/sites",
        headers={"Accept": "application/json", "Authorization": f"Bearer {token}"},
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()


if __name__ == "__main__":
    username = get_env("ROCKETNET_USERNAME")
    password = get_env("ROCKETNET_PASSWORD")

    with httpx.Client() as client:
        token = login(client, username, password)
        sites = list_sites(client, token)
        print(sites)

Go (net/http)

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

const baseURL = "https://api.rocket.net"

type loginRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type loginResponse struct {
	Token string `json:"token"`
}

func mustEnv(name string) string {
	v := os.Getenv(name)
	if v == "" {
		fmt.Fprintf(os.Stderr, "missing env var: %s\n", name)
		os.Exit(1)
	}
	return v
}

func doJSON(req *http.Request, out any) error {
	req.Header.Set("Accept", "application/json")
	res, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	if res.StatusCode < 200 || res.StatusCode >= 300 {
		return fmt.Errorf("http %d: %s", res.StatusCode, string(body))
	}
	return json.Unmarshal(body, out)
}

func login(username, password string) (string, error) {
	payload, _ := json.Marshal(loginRequest{Username: username, Password: password})
	req, _ := http.NewRequest("POST", baseURL+"/v1/login", bytes.NewReader(payload))
	req.Header.Set("Content-Type", "application/json")

	var out loginResponse
	if err := doJSON(req, &out); err != nil {
		return "", err
	}
	if out.Token == "" {
		return "", fmt.Errorf("login response missing token")
	}
	return out.Token, nil
}

func listSites(token string) (map[string]any, error) {
	req, _ := http.NewRequest("GET", baseURL+"/v1/sites", nil)
	req.Header.Set("Authorization", "Bearer "+token)

	var out map[string]any
	if err := doJSON(req, &out); err != nil {
		return nil, err
	}
	return out, nil
}

func main() {
	username := mustEnv("ROCKETNET_USERNAME")
	password := mustEnv("ROCKETNET_PASSWORD")

	token, err := login(username, password)
	if err != nil {
		panic(err)
	}

	sites, err := listSites(token)
	if err != nil {
		panic(err)
	}

	pretty, _ := json.MarshalIndent(sites, "", "  ")
	fmt.Println(string(pretty))
}

TypeScript (fetch, Node.js 18+)

Uses the built-in global fetch. Run with npx tsx your-script.ts or compile with tsc first.

/**
 * Requires Node.js 18+ (global fetch).
 * Run: npx tsx rocket-example.ts
 */
const BASE_URL = "https://api.rocket.net";

function mustEnv(name: string): string {
  const v = process.env[name];
  if (!v) {
    console.error(`Missing env var: ${name}`);
    process.exit(1);
  }
  return v;
}

async function main(): Promise<void> {
  const username = mustEnv("ROCKETNET_USERNAME");
  const password = mustEnv("ROCKETNET_PASSWORD");

  const loginRes = await fetch(`${BASE_URL}/v1/login`, {
    method: "POST",
    headers: {
      Accept: "application/json",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ username, password }),
  });
  const loginBody = (await loginRes.json()) as { token?: string };
  if (!loginRes.ok) {
    throw new Error(`Login failed (${loginRes.status}): ${JSON.stringify(loginBody)}`);
  }
  const token = loginBody.token;
  if (!token) {
    throw new Error("Login response missing token");
  }

  const sitesRes = await fetch(`${BASE_URL}/v1/sites`, {
    headers: {
      Accept: "application/json",
      Authorization: `Bearer ${token}`,
    },
  });
  const sitesBody = await sitesRes.json();
  if (!sitesRes.ok) {
    throw new Error(`Sites request failed (${sitesRes.status}): ${JSON.stringify(sitesBody)}`);
  }

  console.log(JSON.stringify(sitesBody, null, 2));
}

main().catch((err: unknown) => {
  console.error(err);
  process.exit(1);
});

Download OpenAPI

Prefer generating a client? Download openapi.yaml.