DartNode API

import requests

API_TOKEN = "dnt_your_token_here"
BASE_URL = "https://api.dartnode.net/v1"

resp = requests.get(f"{BASE_URL}/account",
    headers={"Authorization": f"Bearer {API_TOKEN}"})

data = resp.json()
print(f"Hello, {data['data']['first_name']}!")

const API_TOKEN = "dnt_your_token_here";
const BASE_URL = "https://api.dartnode.net/v1";

const resp = await fetch(`${BASE_URL}/account`, {
    headers: { "Authorization": `Bearer ${API_TOKEN}` }
});

const { data } = await resp.json();
console.log(`Hello, ${data.first_name}!`);

$apiToken = "dnt_your_token_here";
$baseUrl = "https://api.dartnode.net/v1";

$ch = curl_init("$baseUrl/account");
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiToken"],
    CURLOPT_RETURNTRANSFER => true,
]);

$data = json_decode(curl_exec($ch), true);
echo "Hello, {$data['data']['first_name']}!";

resp = requests.get(f"{BASE_URL}/account",
    headers={"Authorization": f"Bearer {API_TOKEN}"})

account = resp.json()["data"]
print(f"{account['first_name']} {account['last_name']} ({account['email']})")

const resp = await fetch(`${BASE_URL}/account`, {
    headers: { "Authorization": `Bearer ${API_TOKEN}` }
});

const { data } = await resp.json();
console.log(`${data.first_name} ${data.last_name} (${data.email})`);

$ch = curl_init("$baseUrl/account");
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiToken"],
    CURLOPT_RETURNTRANSFER => true,
]);
$data = json_decode(curl_exec($ch), true)["data"];
echo "{$data['first_name']} {$data['last_name']} ({$data['email']})";

resp = requests.get(f"{BASE_URL}/compute",
    headers={"Authorization": f"Bearer {API_TOKEN}"},
    params={"status": "active", "per_page": 10})

for vm in resp.json()["data"]["services"]:
    print(f"{vm['id']}: {vm['hostname']} ({vm['status']})")

const resp = await fetch(`${BASE_URL}/compute?status=active&per_page=10`, {
    headers: { "Authorization": `Bearer ${API_TOKEN}` }
});

const { data } = await resp.json();
data.services.forEach(vm =>
    console.log(`${vm.id}: ${vm.hostname} (${vm.status})`));

$ch = curl_init("$baseUrl/compute?status=active&per_page=10");
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiToken"],
    CURLOPT_RETURNTRANSFER => true,
]);
$data = json_decode(curl_exec($ch), true)["data"];
foreach ($data["services"] as $vm) {
    echo "{$vm['id']}: {$vm['hostname']} ({$vm['status']})\n";
}

resp = requests.get(f"{BASE_URL}/compute/123",
    headers={"Authorization": f"Bearer {API_TOKEN}"})

vm = resp.json()["data"]
print(f"{vm['hostname']} - {vm['os']} ({vm['status']})")
print(f"CPU: {vm['cpu']['cores']} cores @ {vm['cpu']['usage_percent']}%")
print(f"RAM: {vm['memory']['used_mb']}MB / {vm['memory']['total_mb']}MB")

const resp = await fetch(`${BASE_URL}/compute/123`, {
    headers: { "Authorization": `Bearer ${API_TOKEN}` }
});

const { data: vm } = await resp.json();
console.log(`${vm.hostname} - ${vm.os} (${vm.status})`);
console.log(`CPU: ${vm.cpu.cores} cores @ ${vm.cpu.usage_percent}%`);
console.log(`RAM: ${vm.memory.used_mb}MB / ${vm.memory.total_mb}MB`);

$ch = curl_init("$baseUrl/compute/123");
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiToken"],
    CURLOPT_RETURNTRANSFER => true,
]);
$vm = json_decode(curl_exec($ch), true)["data"];
echo "{$vm['hostname']} - {$vm['os']} ({$vm['status']})";

resp = requests.post(f"{BASE_URL}/compute/123/power",
    headers={"Authorization": f"Bearer {API_TOKEN}"},
    json={"action": "shutdown"})

print(resp.json()["data"]["message"])

const resp = await fetch(`${BASE_URL}/compute/123/power`, {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_TOKEN}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({ action: "shutdown" })
});

console.log((await resp.json()).data.message);

$ch = curl_init("$baseUrl/compute/123/power");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer $apiToken",
        "Content-Type: application/json"
    ],
    CURLOPT_POSTFIELDS => json_encode(["action" => "shutdown"]),
    CURLOPT_RETURNTRANSFER => true,
]);
echo json_decode(curl_exec($ch), true)["data"]["message"];

resp = requests.put(f"{BASE_URL}/network/ips/192.0.2.1/rdns",
    headers={"Authorization": f"Bearer {API_TOKEN}"},
    json={"value": "mail.example.com"})

print(resp.json()["data"]["message"])

await fetch(`${BASE_URL}/network/ips/192.0.2.1/rdns`, {
    method: "PUT",
    headers: {
        "Authorization": `Bearer ${API_TOKEN}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({ value: "mail.example.com" })
});

$ch = curl_init("$baseUrl/network/ips/192.0.2.1/rdns");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer $apiToken",
        "Content-Type: application/json"
    ],
    CURLOPT_POSTFIELDS => json_encode(["value" => "mail.example.com"]),
    CURLOPT_RETURNTRANSFER => true,
]);
echo curl_exec($ch);

resp = requests.post(f"{BASE_URL}/deploy",
    headers={"Authorization": f"Bearer {API_TOKEN}"},
    json={
        "plan_id": 1,
        "region": "us-dal",
        "hostname": "my-server",
        "os": 1,
        "os_version": 5,
        "backups": True,
        "cycle": 1
    })

deploy = resp.json()["data"]["deploy"]
print(f"Service #{deploy['service_id']} - {deploy['status']}")

const resp = await fetch(`${BASE_URL}/deploy`, {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_TOKEN}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        plan_id: 1,
        region: "us-dal",
        hostname: "my-server",
        os: 1,
        os_version: 5,
        backups: true,
        cycle: 1
    })
});

const { data } = await resp.json();
console.log(`Service #${data.deploy.service_id} - ${data.deploy.status}`);

$ch = curl_init("$baseUrl/deploy");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer $apiToken",
        "Content-Type: application/json"
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "plan_id" => 1,
        "region" => "us-dal",
        "hostname" => "my-server",
        "os" => 1,
        "os_version" => 5,
        "backups" => true,
        "cycle" => 1
    ]),
    CURLOPT_RETURNTRANSFER => true,
]);
$data = json_decode(curl_exec($ch), true)["data"];
echo "Service #{$data['deploy']['service_id']}";

resp = requests.post(f"{BASE_URL}/webhooks",
    headers={"Authorization": f"Bearer {API_TOKEN}"},
    json={
        "name": "Production Alerts",
        "url": "https://yourapp.com/webhooks/dartnode",
        "events": ["service.provisioned", "service.suspended", "invoice.paid"]
    })

webhook = resp.json()["data"]
print(f"Webhook #{webhook['webhook']['id']} created with secret: {webhook['webhook']['secret']}")
                

const resp = await fetch(`${BASE_URL}/webhooks`, {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_TOKEN}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        name: "Production Alerts",
        url: "https://yourapp.com/webhooks/dartnode",
        events: ["service.provisioned", "service.suspended", "invoice.paid"]
    })
});

const { data } = await resp.json();
console.log(`Webhook #${data.webhook.id} created with secret: ${data.webhook.secret}`);
                

const crypto = require("crypto");

function verifyWebhook(payload, signature, timestamp, secretHash) {
    // Reject deliveries older than 5 minutes
    if (Math.abs(Date.now() / 1000 - parseInt(timestamp)) > 300) {
        return false;
    }

    const signedPayload = `${timestamp}.${payload}`;
    const expected = "v1=" + crypto
        .createHmac("sha256", secretHash)
        .update(signedPayload)
        .digest("hex");
    return crypto.timingSafeEqual(
        Buffer.from(expected), Buffer.from(signature)
    );
}

// Usage in Express:
app.post("/webhooks/dartnode", express.raw({ type: "*/*" }), (req, res) => {
    const valid = verifyWebhook(
        req.body.toString(),
        req.headers["x-dartnode-signature"],
        req.headers["x-dartnode-timestamp"],
        WEBHOOK_SECRET
    );

    if (!valid) return res.status(401).send("Invalid signature");

    const event = req.headers["x-dartnode-event"];
    const data = JSON.parse(req.body);
    // Process event...
    res.sendStatus(200);
});

function verifyWebhook(
    string $payload, string $signature,
    string $timestamp, string $secretHash
): bool {
    // Reject deliveries older than 5 minutes
    if (abs(time() - (int) $timestamp) > 300) {
        return false;
    }

    $signedPayload = $timestamp . '.' . $payload;
    $expected = 'v1=' . hash_hmac('sha256', $signedPayload, $secretHash);
    return hash_equals($expected, $signature);
}

// Usage:
$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_DARTNODE_SIGNATURE'];
$timestamp = $_SERVER['HTTP_X_DARTNODE_TIMESTAMP'];

if (!verifyWebhook($payload, $signature, $timestamp, WEBHOOK_SECRET)) {
    http_response_code(401);
    exit('Invalid signature');
}

$event = $_SERVER['HTTP_X_DARTNODE_EVENT'];
$data = json_decode($payload, true);
// Process event...
http_response_code(200);

resp = requests.post("https://api.dartnode.net/v1/oauth/token", data={
    "grant_type": "authorization_code",
    "code": "dnc_xxx",
    "client_id": "dna_your_client_id",
    "client_secret": "dns_your_client_secret",
    "redirect_uri": "https://yourapp.com/callback"
})

tokens = resp.json()["data"]
access_token = tokens["access_token"]   # dno_xxx (1 hour)
refresh_token = tokens["refresh_token"] # dnr_xxx (30 days)

const resp = await fetch("https://api.dartnode.net/v1/oauth/token", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
        grant_type: "authorization_code",
        code: "dnc_xxx",
        client_id: "dna_your_client_id",
        client_secret: "dns_your_client_secret",
        redirect_uri: "https://yourapp.com/callback"
    })
});

const { data } = await resp.json();
const { access_token, refresh_token } = data;

$ch = curl_init("https://api.dartnode.net/v1/oauth/token");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => http_build_query([
        "grant_type" => "authorization_code",
        "code" => "dnc_xxx",
        "client_id" => "dna_your_client_id",
        "client_secret" => "dns_your_client_secret",
        "redirect_uri" => "https://yourapp.com/callback"
    ]),
    CURLOPT_RETURNTRANSFER => true,
]);
$data = json_decode(curl_exec($ch), true)["data"];
$accessToken = $data["access_token"];
$refreshToken = $data["refresh_token"];