Deliver music.
Track everything.

curl -sS -H "Authorization: Bearer $BTR_API_KEY" \
  https://partners.btrmusic.com/api/v1/me

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/me", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req)
  if err != nil { panic(err) }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/me", headers={
    "Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/me", {
  headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` }
});
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/me");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/deliveries \
  -H "Authorization: Bearer $BTR_API_KEY" \
  -F file=@release.zip

package main
import ("fmt"; "io"; "mime/multipart"; "net/http"; "os")
func main() {
  f, err := os.Open("release.zip"); if err != nil { panic(err) }; defer f.Close()
  r, w := io.Pipe()
  form := multipart.NewWriter(w)
  go func() {
    part, e := form.CreateFormFile("file", "release.zip")
    if e == nil { _, e = io.Copy(part, f) }
    if e == nil { e = form.Close() }
    w.CloseWithError(e)
  }()
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/deliveries", r)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  req.Header.Set("Content-Type", form.FormDataContentType())
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode != http.StatusAccepted { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
with open("release.zip", "rb") as package:
    r = requests.post("https://partners.btrmusic.com/api/v1/deliveries",
        headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]},
        files={"file": ("release.zip", package, "application/zip")}, timeout=300)
r.raise_for_status()
print(r.json())  # delivery.ref

import { openAsBlob } from "node:fs";
const form = new FormData();
form.set("file", await openAsBlob("release.zip"), "release.zip");
const res = await fetch("https://partners.btrmusic.com/api/v1/deliveries", {
  method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` }, body: form
});
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var form = new MultipartFormDataContent();
using var file = File.OpenRead("release.zip");
form.Add(new StreamContent(file), "file", "release.zip");
var res = await http.PostAsync("https://partners.btrmusic.com/api/v1/deliveries", form);
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/deliveries \
  -H "Authorization: Bearer $BTR_API_KEY" -F file=@release.zip
# Raw body alternative:
curl -sS -X POST https://partners.btrmusic.com/api/v1/deliveries \
  -H "Authorization: Bearer $BTR_API_KEY" \
  -H "Content-Type: application/zip" -H "X-File-Name: release.zip" \
  --data-binary @release.zip

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  f, err := os.Open("release.zip"); if err != nil { panic(err) }; defer f.Close()
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/deliveries", f)
  if err != nil { panic(err) }
  req.Header.Set("Content-Type", "application/zip")
  req.Header.Set("X-File-Name", "release.zip")
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode != 202 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
with open("release.zip", "rb") as package:
    r = requests.post("https://partners.btrmusic.com/api/v1/deliveries", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, files={"file": ("release.zip", package, "application/zip")}, timeout=300)
r.raise_for_status()
print(r.json())

import { openAsBlob } from "node:fs";
const form = new FormData();
form.set("file", await openAsBlob("release.zip"), "release.zip");
const res = await fetch("https://partners.btrmusic.com/api/v1/deliveries", {
  method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` }, body: form
});
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var file = File.OpenRead("release.zip");
using var content = new StreamContent(file);
content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
using var req = new HttpRequestMessage(HttpMethod.Post, "https://partners.btrmusic.com/api/v1/deliveries") { Content = content };
req.Headers.TryAddWithoutValidation("X-File-Name", "release.zip");
using var res = await http.SendAsync(req);
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS https://partners.btrmusic.com/api/v1/deliveries/{ref} \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/deliveries/0a9e1f2c-4b6d-4e8a-9f10-1c2d3e4f5a6b");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS "https://partners.btrmusic.com/api/v1/deliveries?status=rejected&limit=50" \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/deliveries?status=rejected&limit=50", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/deliveries?status=rejected&limit=50", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/deliveries?status=rejected&limit=50", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/deliveries?status=rejected&limit=50");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS https://partners.btrmusic.com/api/v1/releases/0634479384622 \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/releases/0634479384622", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/releases/0634479384622", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/releases/0634479384622", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/releases/0634479384622");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS "https://partners.btrmusic.com/api/v1/releases?status=live&limit=100" \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/releases?status=live&limit=100", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/releases?status=live&limit=100", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/releases?status=live&limit=100", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/releases?status=live&limit=100");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/releases/0634479384622/artist \
  -H "Authorization: Bearer $BTR_API_KEY" -H "Content-Type: application/json" \
  -d '{"btr_user_id":"6512a1b2c3d4e5f60718293a"}'

package main
import ("fmt"; "io"; "net/http"; "os"; "strings")
func main() {
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/releases/0634479384622/artist", strings.NewReader(`{"btr_user_id":"6512a1b2c3d4e5f60718293a"}`))
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.post("https://partners.btrmusic.com/api/v1/releases/0634479384622/artist", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, json={"btr_user_id":"6512a1b2c3d4e5f60718293a"}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/releases/0634479384622/artist", { method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({"btr_user_id":"6512a1b2c3d4e5f60718293a"}) });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.PostAsync("https://partners.btrmusic.com/api/v1/releases/0634479384622/artist", new StringContent("{\"btr_user_id\":\"6512a1b2c3d4e5f60718293a\"}", System.Text.Encoding.UTF8, "application/json"));
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/releases/0634479384622/takedown \
  -H "Authorization: Bearer $BTR_API_KEY" -H "Content-Type: application/json" \
  -d '{"reason":"Rights reverted by the licensor"}'

package main
import ("fmt"; "io"; "net/http"; "os"; "strings")
func main() {
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/releases/0634479384622/takedown", strings.NewReader(`{"reason":"Rights reverted by the licensor"}`))
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.post("https://partners.btrmusic.com/api/v1/releases/0634479384622/takedown", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, json={"reason":"Rights reverted by the licensor"}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/releases/0634479384622/takedown", { method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({"reason":"Rights reverted by the licensor"}) });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.PostAsync("https://partners.btrmusic.com/api/v1/releases/0634479384622/takedown", new StringContent("{\"reason\":\"Rights reverted by the licensor\"}", System.Text.Encoding.UTF8, "application/json"));
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/releases/0634479384622/submit \
  -H "Authorization: Bearer $BTR_API_KEY" -H "Content-Type: application/json" \
  -d '{"resource_ids":["6512a1b2c3d4e5f60718293a"]}'

package main
import ("fmt"; "io"; "net/http"; "os"; "strings")
func main() {
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/releases/0634479384622/submit", strings.NewReader(`{"resource_ids":["6512a1b2c3d4e5f60718293a"]}`))
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.post("https://partners.btrmusic.com/api/v1/releases/0634479384622/submit", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, json={"resource_ids":["6512a1b2c3d4e5f60718293a"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/releases/0634479384622/submit", { method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({"resource_ids":["6512a1b2c3d4e5f60718293a"]}) });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.PostAsync("https://partners.btrmusic.com/api/v1/releases/0634479384622/submit", new StringContent("{\"resource_ids\":[\"6512a1b2c3d4e5f60718293a\"]}", System.Text.Encoding.UTF8, "application/json"));
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/artists \
  -H "Authorization: Bearer $BTR_API_KEY" -H "Content-Type: application/json" \
  -d '{"btr_username":"nova-lang","email":"artist@example.com","rights_confirmed":true}'

package main
import ("fmt"; "io"; "net/http"; "os"; "strings")
func main() {
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/artists", strings.NewReader(`{"btr_username":"nova-lang","email":"artist@example.com","rights_confirmed":true}`))
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.post("https://partners.btrmusic.com/api/v1/artists", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, json={"btr_username":"nova-lang","email":"artist@example.com","rights_confirmed":true}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/artists", { method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({"btr_username":"nova-lang","email":"artist@example.com","rights_confirmed":true}) });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.PostAsync("https://partners.btrmusic.com/api/v1/artists", new StringContent("{\"btr_username\":\"nova-lang\",\"email\":\"artist@example.com\",\"rights_confirmed\":true}", System.Text.Encoding.UTF8, "application/json"));
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS https://partners.btrmusic.com/api/v1/artists \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/artists", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/artists", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/artists", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/artists");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS -X POST https://partners.btrmusic.com/api/v1/reports/2026-08 \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodPost, "https://partners.btrmusic.com/api/v1/reports/2026-08", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.post("https://partners.btrmusic.com/api/v1/reports/2026-08", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/reports/2026-08", { method: "POST", headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.PostAsync("https://partners.btrmusic.com/api/v1/reports/2026-08", null);
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS "https://partners.btrmusic.com/api/v1/reports/2026-08?format=csv" \
  -H "Authorization: Bearer $BTR_API_KEY" -o usage.csv

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/reports/2026-08?format=csv", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status); os.Exit(1) }
  out, err := os.Create("usage.csv"); if err != nil { panic(err) }; defer out.Close()
  if _, err := io.Copy(out, res.Body); err != nil { panic(err) }
}

import os
import requests
with requests.get("https://partners.btrmusic.com/api/v1/reports/2026-08?format=csv", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, stream=True, timeout=60) as r:
    r.raise_for_status()
    with open("usage.csv", "wb") as output:
        for chunk in r.iter_content(chunk_size=65536):
            output.write(chunk)

import { writeFile } from "node:fs/promises";
const res = await fetch("https://partners.btrmusic.com/api/v1/reports/2026-08?format=csv", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
await writeFile("usage.csv", Buffer.from(await res.arrayBuffer()));

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/reports/2026-08?format=csv");
res.EnsureSuccessStatusCode();
await File.WriteAllBytesAsync("usage.csv", await res.Content.ReadAsByteArrayAsync());

curl -sS https://partners.btrmusic.com/api/v1/reports \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/reports", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/reports", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/reports", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/reports");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS https://partners.btrmusic.com/api/v1/reference/genres \
  -H "Authorization: Bearer $BTR_API_KEY"

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/reference/genres", nil)
  if err != nil { panic(err) }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("BTR_API_KEY"))
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import os
import requests
r = requests.get("https://partners.btrmusic.com/api/v1/reference/genres", headers={"Authorization": "Bearer " + os.environ["BTR_API_KEY"]}, timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/reference/genres", { headers: { Authorization: `Bearer ${process.env.BTR_API_KEY}` } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("BTR_API_KEY"));
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/reference/genres");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

curl -sS https://partners.btrmusic.com/api/v1/health

package main
import ("fmt"; "io"; "net/http"; "os")
func main() {
  req, err := http.NewRequest(http.MethodGet, "https://partners.btrmusic.com/api/v1/health", nil)
  if err != nil { panic(err) }
  res, err := http.DefaultClient.Do(req); if err != nil { panic(err) }; defer res.Body.Close()
  body, err := io.ReadAll(res.Body); if err != nil { panic(err) }
  if res.StatusCode >= 300 { fmt.Fprintln(os.Stderr, res.Status, string(body)); os.Exit(1) }
  fmt.Println(string(body))
}

import requests
r = requests.get("https://partners.btrmusic.com/api/v1/health", timeout=30)
r.raise_for_status()
print(r.json())

const res = await fetch("https://partners.btrmusic.com/api/v1/health", { headers: {  } });
if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

using System.Net.Http;
using System.Net.Http.Headers;
using var http = new HttpClient();
using var res = await http.GetAsync("https://partners.btrmusic.com/api/v1/health");
res.EnsureSuccessStatusCode();
Console.WriteLine(await res.Content.ReadAsStringAsync());

# curl can send a test webhook, but signature verification belongs in your server.
# Select Go, Python, Node.js or C# above for a verification example.

// Imports: crypto/hmac, crypto/sha256, encoding/hex, time, strconv.
func verify(secret, ts, sig string, body []byte) bool {
  n, err := strconv.ParseInt(ts, 10, 64)
  if err != nil || dabs(time.Now().Unix()-n) > 300 { return false }
  mac := hmac.New(sha256.New, []byte(secret))
  mac.Write([]byte(ts + ".")); mac.Write(body)
  want := "sha256=" + hex.EncodeToString(mac.Sum(nil))
  return hmac.Equal([]byte(want), []byte(sig))
}
func dabs(n int64) int64 { if n < 0 { return -n }; return n }

import hashlib, hmac, time

def verify(secret: str, timestamp: str, signature: str, raw_body: bytes) -> bool:
    try:
        if abs(time.time() - int(timestamp)) > 300: return False
    except ValueError:
        return False
    msg = timestamp.encode() + b"." + raw_body
    want = "sha256=" + hmac.new(secret.encode(), msg, hashlib.sha256).hexdigest()
    return hmac.compare_digest(want, signature)

import { createHmac, timingSafeEqual } from "node:crypto";
export function verify(secret, timestamp, signature, rawBody) {
  const ts = Number(timestamp);
  if (!Number.isSafeInteger(ts) || Math.abs(Date.now() / 1000 - ts) > 300) return false;
  const expected = "sha256=" + createHmac("sha256", secret)
    .update(timestamp + ".").update(rawBody).digest("hex");
  const a = Buffer.from(expected), b = Buffer.from(signature);
  return a.length === b.length && timingSafeEqual(a, b);
}

// Imports: System.Security.Cryptography, System.Text, System.Linq.
static bool Verify(string secret, string timestamp, string signature, byte[] rawBody) {
    if (!long.TryParse(timestamp, out var ts) ||
        Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - ts) > 300) return false;
    using var mac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
    var message = Encoding.UTF8.GetBytes(timestamp + ".").Concat(rawBody).ToArray();
    var want = "sha256=" + Convert.ToHexString(mac.ComputeHash(message)).ToLowerInvariant();
    return CryptographicOperations.FixedTimeEquals(
        Encoding.UTF8.GetBytes(want), Encoding.UTF8.GetBytes(signature));
}