# pip install requests
import requests

BASE_URL = "https://www.anirena.com"

# One request: authenticate (with 2FA if enabled) and get a bearer token.
# Set new_api_key=True to also receive a brand-new permanent API key.
resp = requests.post(
    f"{BASE_URL}/api/v1/auth/login",
    json={
        "login":       "your-username",  # username or email
        "password":    "your-password",
        "totp_code":   "123456",         # omit if 2FA is not enabled
        "new_api_key": True,             # optional
    },
)
resp.raise_for_status()
data  = resp.json()
token = data["token"]  # use as: Authorization: Bearer <token>
if "api_key" in data:
    print("New API key — store it now:", data["api_key"])

// Built-in fetch — requires Node.js 18+
const BASE_URL = "https://www.anirena.com";

// One request: authenticate (with 2FA if enabled) and get a bearer token.
// Set new_api_key:true to also receive a brand-new permanent API key.
const resp = await fetch(`${BASE_URL}/api/v1/auth/login`, {
  method:  "POST",
  headers: { "Content-Type": "application/json" },
  body:    JSON.stringify({
    login:       "your-username",  // username or email
    password:    "your-password",
    totp_code:   "123456",         // omit if 2FA is not enabled
    new_api_key: true,             // optional
  }),
});
const data  = await resp.json();
const token = data.token;  // use as: Authorization: Bearer <token>
if (data.api_key) console.log("New API key — store it now:", data.api_key);

// Requires: curl extension (enabled by default in PHP 8+)
<?php
define("BASE_URL", "https://www.anirena.com");

// One request: authenticate (with 2FA if enabled) and get a bearer token.
// Set new_api_key => true to also receive a brand-new permanent API key.
$ch = curl_init(BASE_URL . "/api/v1/auth/login");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode([
        "login"       => "your-username",  // username or email
        "password"    => "your-password",
        "totp_code"   => "123456",         // omit if 2FA is not enabled
        "new_api_key" => true,             // optional
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ["Content-Type: application/json"],
]);
$data  = json_decode(curl_exec($ch), true);
curl_close($ch);
$token = $data["token"];  // use as: Authorization: Bearer <token>
if (isset($data["api_key"]))
    echo "New API key — store it now: " . $data["api_key"];

// Cargo.toml:
//   serde_json = "1"
//   reqwest    = { version = "0.12", features = ["blocking", "json"] }
const BASE_URL: &str = "https://www.anirena.com";

fn main() {
    let client = reqwest::blocking::Client::new();

    // One request: authenticate (with 2FA if enabled) and get a bearer token.
    // Set new_api_key:true to also receive a brand-new permanent API key.
    let data: serde_json::Value = client
        .post(format!("{BASE_URL}/api/v1/auth/login"))
        .json(&serde_json::json!({
            "login":       "your-username",  // username or email
            "password":    "your-password",
            "totp_code":   "123456",         // omit if 2FA is not enabled
            "new_api_key": true,             // optional
        }))
        .send().unwrap()
        .json().unwrap();

    let token = data["token"].as_str().unwrap();  // Authorization: Bearer <token>
    if let Some(key) = data["api_key"].as_str() {
        println!("New API key — store it now: {key}");
    }
}

# pip install requests
import base64, pathlib, requests

API_KEY  = "YOUR_API_KEY"
BASE_URL = "https://www.anirena.com"

# Step 1: exchange API key for a short-lived bearer token
auth = requests.post(
    f"{BASE_URL}/api/v1/auth/token",
    headers={"Authorization": f"ApiKey {API_KEY}"},
)
auth.raise_for_status()
token = auth.json()["token"]

# Step 2: upload — plain JSON with the bearer token
torrent_b64 = base64.b64encode(pathlib.Path("file.torrent").read_bytes()).decode()
resp = requests.post(
    f"{BASE_URL}/api/v1/torrents",
    json={
        "torrent":      torrent_b64,
        "category":     "anime",
        "sub_category": "raw",
        "languages":    ["ja"],
        "description":  "# My Release\n\nRelease notes here.",
        "is_private":   False,
    },
    headers={"Authorization": f"Bearer {token}"},
)
resp.raise_for_status()
data  = resp.json()
token = resp.headers.get("X-New-Token", token)  # save for next request
print(data["id"], data["name"])  # torrent UUID and title

// Built-in modules only — requires Node.js 18+ (for global fetch)
const fs = require("fs");

const API_KEY  = "YOUR_API_KEY";
const BASE_URL = "https://www.anirena.com";

// Step 1: exchange API key for a short-lived bearer token
let authResp = await fetch(`${BASE_URL}/api/v1/auth/token`, {
  method: "POST", headers: { Authorization: `ApiKey ${API_KEY}` },
});
let { token } = await authResp.json();

// Step 2: upload — plain JSON with the bearer token
const torrentB64 = fs.readFileSync("file.torrent").toString("base64");
const resp = await fetch(`${BASE_URL}/api/v1/torrents`, {
  method:  "POST",
  headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
  body:    JSON.stringify({
    torrent:      torrentB64,
    category:     "anime",
    sub_category: "raw",
    languages:    ["ja"],
    description:  "# My Release\n\nRelease notes here.",
    is_private:   false,
  }),
});
const data = await resp.json();
token = resp.headers.get("x-new-token") ?? token;  // save for next request
console.log(data.id, data.name);  // torrent UUID and title

// Requires: curl extension (enabled by default in PHP 8+)
<?php
define("API_KEY",  "YOUR_API_KEY");
define("BASE_URL", "https://www.anirena.com");

// Step 1: exchange API key for a short-lived bearer token
$ch = curl_init(BASE_URL . "/api/v1/auth/token");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ["Authorization: ApiKey " . API_KEY],
]);
$token = json_decode(curl_exec($ch), true)["token"];
curl_close($ch);

// Step 2: upload — plain JSON with the bearer token
$torrentB64  = base64_encode(file_get_contents("file.torrent"));
$respHeaders = [];
$ch = curl_init(BASE_URL . "/api/v1/torrents");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode([
        "torrent"      => $torrentB64,
        "category"     => "anime",
        "sub_category" => "raw",
        "languages"    => ["ja"],
        "description"  => "# My Release\n\nRelease notes here.",
        "is_private"   => false,
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADERFUNCTION => function($ch, $h) use (&$respHeaders) {
        $respHeaders[] = $h; return strlen($h);
    },
    CURLOPT_HTTPHEADER     => [
        "Content-Type: application/json",
        "Authorization: Bearer " . $token,
    ],
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
foreach ($respHeaders as $h) {  // save new token for next request
    if (stripos($h, "X-New-Token:") === 0)
        $token = trim(substr($h, strlen("X-New-Token:")));
}
echo $data["id"] . " " . $data["name"];  // torrent UUID and title

// Cargo.toml:
//   base64     = "0.22"
//   serde_json = "1"
//   reqwest    = { version = "0.12", features = ["blocking", "json"] }
use base64::{engine::general_purpose::STANDARD as B64, Engine};

const API_KEY:  &str = "YOUR_API_KEY";
const BASE_URL: &str = "https://www.anirena.com";

fn main() {
    let client = reqwest::blocking::Client::new();

    // Step 1: exchange API key for a short-lived bearer token
    let auth: serde_json::Value = client
        .post(format!("{BASE_URL}/api/v1/auth/token"))
        .header("Authorization", format!("ApiKey {API_KEY}"))
        .send().unwrap().json().unwrap();
    let mut token = auth["token"].as_str().unwrap().to_string();

    // Step 2: upload — plain JSON with the bearer token
    let torrent_b64 = B64.encode(std::fs::read("file.torrent").unwrap());
    let resp = client
        .post(format!("{BASE_URL}/api/v1/torrents"))
        .header("Authorization", format!("Bearer {token}"))
        .json(&serde_json::json!({
            "torrent":      torrent_b64,
            "category":     "anime",
            "sub_category": "raw",
            "languages":    ["ja"],
            "description":  "# My Release\n\nRelease notes here.",
            "is_private":   false
        }))
        .send().unwrap();
    if let Some(t) = resp.headers().get("x-new-token") {
        token = t.to_str().unwrap().to_string();  // save for next request
    }
    let data: serde_json::Value = resp.json().unwrap();
    println!("{} {}", data["id"], data["name"]);  // torrent UUID and title
}

# Install system dependencies
sudo apt-get install build-essential cmake libtorrent-rasterbar-dev

# Clone & build
git clone https://github.com/cantalupo555/torrent-builder.git
cd torrent-builder
mkdir build && cd build
cmake .. && cmake --build .

# Install dependencies via Homebrew
brew install cmake libtorrent-rasterbar

# Clone & build
git clone https://github.com/cantalupo555/torrent-builder.git
cd torrent-builder
mkdir build && cd build
cmake .. && cmake --build .

# pip install requests
import base64, subprocess, requests

API_KEY  = "YOUR_API_KEY"
BASE_URL = "https://www.anirena.com"

# Step 1: build the torrent with torrent-builder
# --version 1=v1  2=v2  3=hybrid (default)
subprocess.run([
    "./torrent-builder/build/torrent_builder",
    "--path",    "/data/my_release",
    "--output",  "my_release.torrent",
    "--version", "3",                      # hybrid
    "--tracker", "udp://open.tracker.gg:6969/announce",
    "--comment", "My Release",
    "--creator", "--creation-date",
], check=True)

# Step 2: authenticate
token = requests.post(
    f"{BASE_URL}/api/v1/auth/token",
    headers={"Authorization": f"ApiKey {API_KEY}"},
).json()["token"]

# Step 3: upload
torrent_b64 = base64.b64encode(open("my_release.torrent", "rb").read()).decode()
resp = requests.post(
    f"{BASE_URL}/api/v1/torrents",
    json={
        "torrent":          torrent_b64,
        "category":         "anime",
        "sub_category":     "raw",
        "languages":        ["ja"],
        "comments_enabled": True,
    },
    headers={"Authorization": f"Bearer {token}"},
)
resp.raise_for_status()
data = resp.json()
print(data["id"], data["name"])

// Built-in modules — Node.js 18+
const fs = require("fs");
const { execFileSync } = require("child_process");

const API_KEY  = "YOUR_API_KEY";
const BASE_URL = "https://www.anirena.com";

// Step 1: build the torrent (--version 1=v1, 2=v2, 3=hybrid)
execFileSync("./torrent-builder/build/torrent_builder", [
  "--path",    "/data/my_release",
  "--output",  "my_release.torrent",
  "--version", "3",
  "--tracker", "udp://open.tracker.gg:6969/announce",
  "--comment", "My Release",
  "--creator", "--creation-date",
]);

// Step 2: authenticate
let { token } = await (await fetch(`${BASE_URL}/api/v1/auth/token`, {
  method: "POST", headers: { Authorization: `ApiKey ${API_KEY}` },
})).json();

// Step 3: upload
const torrentB64 = fs.readFileSync("my_release.torrent").toString("base64");
const resp = await fetch(`${BASE_URL}/api/v1/torrents`, {
  method:  "POST",
  headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
  body: JSON.stringify({
    torrent:          torrentB64,
    category:         "anime",
    sub_category:     "raw",
    languages:        ["ja"],
    comments_enabled: true,
  }),
});
const data = await resp.json();
console.log(data.id, data.name);

// PHP 8+ with curl and proc_open
<?php
define("API_KEY",  "YOUR_API_KEY");
define("BASE_URL", "https://www.anirena.com");

// Step 1: build the torrent (version: 1=v1, 2=v2, 3=hybrid)
exec(implode(" ", array_map("escapeshellarg", [
    "./torrent-builder/build/torrent_builder",
    "--path",    "/data/my_release",
    "--output",  "my_release.torrent",
    "--version", "3",
    "--tracker", "udp://open.tracker.gg:6969/announce",
    "--comment", "My Release",
    "--creator", "--creation-date",
])));

// Step 2: authenticate
$ch = curl_init(BASE_URL . "/api/v1/auth/token");
curl_setopt_array($ch, [CURLOPT_POST => true, CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: ApiKey " . API_KEY]]);
$token = json_decode(curl_exec($ch), true)["token"];
curl_close($ch);

// Step 3: upload
$torrentB64  = base64_encode(file_get_contents("my_release.torrent"));
$respHeaders = [];
$ch = curl_init(BASE_URL . "/api/v1/torrents");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode([
        "torrent"          => $torrentB64,
        "category"         => "anime",
        "sub_category"     => "raw",
        "languages"        => ["ja"],
        "comments_enabled" => true,
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADERFUNCTION => function($ch, $h) use (&$respHeaders) {
        $respHeaders[] = $h; return strlen($h);
    },
    CURLOPT_HTTPHEADER => ["Content-Type: application/json",
                            "Authorization: Bearer " . $token],
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $data["id"] . " " . $data["name"];

// Cargo.toml:
//   base64     = "0.22"
//   serde_json = "1"
//   reqwest    = { version = "0.12", features = ["blocking", "json"] }
use base64::{engine::general_purpose::STANDARD as B64, Engine};
use std::process::Command;

const API_KEY:  &str = "YOUR_API_KEY";
const BASE_URL: &str = "https://www.anirena.com";

fn main() {
    // Step 1: build the torrent (--version 1=v1, 2=v2, 3=hybrid)
    Command::new("./torrent-builder/build/torrent_builder")
        .args([
            "--path",    "/data/my_release",
            "--output",  "my_release.torrent",
            "--version", "3",
            "--tracker", "udp://open.tracker.gg:6969/announce",
            "--comment", "My Release",
            "--creator", "--creation-date",
        ])
        .status().expect("torrent_builder failed");

    let client = reqwest::blocking::Client::new();

    // Step 2: authenticate
    let auth: serde_json::Value = client
        .post(format!("{BASE_URL}/api/v1/auth/token"))
        .header("Authorization", format!("ApiKey {API_KEY}"))
        .send().unwrap().json().unwrap();
    let token = auth["token"].as_str().unwrap().to_string();

    // Step 3: upload
    let torrent_b64 = B64.encode(std::fs::read("my_release.torrent").unwrap());
    let resp: serde_json::Value = client
        .post(format!("{BASE_URL}/api/v1/torrents"))
        .header("Authorization", format!("Bearer {token}"))
        .json(&serde_json::json!({
            "torrent":          torrent_b64,
            "category":         "anime",
            "sub_category":     "raw",
            "languages":        ["ja"],
            "comments_enabled": true,
        }))
        .send().unwrap().json().unwrap();
    println!("{} {}", resp["id"], resp["name"]);
}

# pip install requests  (token already obtained — see upload example)
resp = requests.post(
    f"{BASE_URL}/api/v1/torrents/search",
    json={"q": "Sword Art Online", "category": "anime", "per_page": 25},
    headers={"Authorization": f"Bearer {token}"},
)
resp.raise_for_status()
data  = resp.json()
token = resp.headers.get("X-New-Token", token)  # save for next request
for t in data["torrents"]:
    print(t["title"], "-", t["magnet"])

// token already obtained — see upload example
const resp = await fetch(`${BASE_URL}/api/v1/torrents/search`, {
  method:  "POST",
  headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
  body:    JSON.stringify({ q: "Sword Art Online", category: "anime", per_page: 25 }),
});
const data = await resp.json();
token = resp.headers.get("x-new-token") ?? token;  // save for next request
data.torrents.forEach(t => console.log(t.title, "-", t.magnet));

// token already obtained — see upload example
$respHeaders = [];
$ch = curl_init(BASE_URL . "/api/v1/torrents/search");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => json_encode([
        "q" => "Sword Art Online", "category" => "anime", "per_page" => 25
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADERFUNCTION => function($ch, $h) use (&$respHeaders) {
        $respHeaders[] = $h; return strlen($h);
    },
    CURLOPT_HTTPHEADER     => [
        "Content-Type: application/json",
        "Authorization: Bearer " . $token,
    ],
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
foreach ($respHeaders as $h) {  // save new token for next request
    if (stripos($h, "X-New-Token:") === 0)
        $token = trim(substr($h, strlen("X-New-Token:")));
}
foreach ($data["torrents"] as $t) {
    echo $t["title"] . " - " . $t["magnet"] . "\n";
}

// client and token already obtained — see upload example
let resp = client
    .post(format!("{BASE_URL}/api/v1/torrents/search"))
    .header("Authorization", format!("Bearer {token}"))
    .json(&serde_json::json!({"q": "Sword Art Online", "category": "anime", "per_page": 25}))
    .send().unwrap();
if let Some(t) = resp.headers().get("x-new-token") {
    token = t.to_str().unwrap().to_string();  // save for next request
}
let data: serde_json::Value = resp.json().unwrap();
for t in data["torrents"].as_array().unwrap() {
    println!("{} - {}", t["title"], t["magnet"]);
}

# pip install requests  (token already obtained — see upload example)
TORRENT_ID = "550e8400-e29b-41d4-a716-446655440000"
resp = requests.get(
    f"{BASE_URL}/api/v1/torrents/{TORRENT_ID}/comments",
    params={"page": 1},
    headers={"Authorization": f"Bearer {token}"},
)
resp.raise_for_status()
data  = resp.json()
token = resp.headers.get("X-New-Token", token)  # save for next request
for c in data["comments"]:
    print(c["username"], "-", c["body"])

// token already obtained — see upload example
const TORRENT_ID = "550e8400-e29b-41d4-a716-446655440000";
const resp = await fetch(`${BASE_URL}/api/v1/torrents/${TORRENT_ID}/comments?page=1`, {
  headers: { Authorization: `Bearer ${token}` },
});
const data = await resp.json();
token = resp.headers.get("x-new-token") ?? token;  // save for next request
data.comments.forEach(c => console.log(c.username, "-", c.body));

// token already obtained — see upload example
$torrentId   = "550e8400-e29b-41d4-a716-446655440000";
$respHeaders = [];
$ch = curl_init(BASE_URL . "/api/v1/torrents/{$torrentId}/comments?page=1");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HEADERFUNCTION => function($ch, $h) use (&$respHeaders) {
        $respHeaders[] = $h; return strlen($h);
    },
    CURLOPT_HTTPHEADER => ["Authorization: Bearer " . $token],
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
foreach ($respHeaders as $h) {  // save new token for next request
    if (stripos($h, "X-New-Token:") === 0)
        $token = trim(substr($h, strlen("X-New-Token:")));
}
foreach ($data["comments"] as $c) {
    echo $c["username"] . " - " . $c["body"] . "\n";
}

// client and token already obtained — see upload example
let torrent_id = "550e8400-e29b-41d4-a716-446655440000";
let resp = client
    .get(format!("{BASE_URL}/api/v1/torrents/{torrent_id}/comments?page=1"))
    .header("Authorization", format!("Bearer {token}"))
    .send().unwrap();
if let Some(t) = resp.headers().get("x-new-token") {
    token = t.to_str().unwrap().to_string();  // save for next request
}
let data: serde_json::Value = resp.json().unwrap();
for c in data["comments"].as_array().unwrap() {
    println!("{} - {}", c["username"], c["body"]);
}

# pip install requests  (no authentication required)
resp = requests.get(
    f"{BASE_URL}/api/v1/anime/search",
    params={"q": "Sword Art Online", "page": 1, "per_page": 10},
)
resp.raise_for_status()
for item in resp.json()["results"]:
    print(item["id"], "-", item["title"])

// No authentication required
const resp = await fetch(
  `${BASE_URL}/api/v1/anime/search?q=${encodeURIComponent("Sword Art Online")}&page=1&per_page=10`
);
const data = await resp.json();
data.results.forEach(item => console.log(item.id, "-", item.title));

// No authentication required
$ch = curl_init(BASE_URL . "/api/v1/anime/search?" . http_build_query([
    "q" => "Sword Art Online", "page" => 1, "per_page" => 10,
]));
curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER => true]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
foreach ($data["results"] as $item) {
    echo $item["id"] . " - " . $item["title"] . "\n";
}

// No authentication required
let data: serde_json::Value = reqwest::blocking::get(
    format!("{BASE_URL}/api/v1/anime/search?q=Sword+Art+Online&page=1&per_page=10")
).unwrap().json().unwrap();
for item in data["results"].as_array().unwrap() {
    println!("{} - {}", item["id"], item["title"]);
}