ArtyShield APIs

import requests

base = "https://api.artyshield.ai/functions/v1"
headers = {
    "X-API-Key": "USER_API_KEY",
    "apikey": "ANON_KEY",
    "Authorization": "Bearer ANON_KEY",
    "Content-Type": "application/json",
}

queue = requests.post(
    f"{base}/musicshield-from-url",
    headers=headers,
    json={
        "url": "https://cdn.example.com/catalog/mixdown.wav",
        "filename": "mixdown.wav",
        "protectionStrength": 5,
        "analysis": True,
        # Optional request-level callback:
        # "webhookUrl": "https://your-app.example.com/webhooks/artyshield",
        # "webhookSecret": "whsec_your_signing_secret",
    },
    timeout=300,
)
queue.raise_for_status()
data = queue.json()
print("fileId:", data["fileId"])
print("protectionId:", data["protectionId"])
print("version:", data.get("version"))

const base = "https://api.artyshield.ai/functions/v1";
const headers = {
  "X-API-Key": "USER_API_KEY",
  "apikey": "ANON_KEY",
  "Authorization": "Bearer ANON_KEY",
  "Content-Type": "application/json",
};

async function runMusicShield() {
  const queueResp = await fetch(`${base}/musicshield-from-url`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      url: "https://cdn.example.com/catalog/mixdown.wav",
      filename: "mixdown.wav",
      protectionStrength: 5,
      analysis: true,
      // Optional request-level callback:
      // webhookUrl: "https://your-app.example.com/webhooks/artyshield",
      // webhookSecret: "whsec_your_signing_secret",
    }),
  });
  if (!queueResp.ok) {
    const body = await queueResp.text();
    throw new Error(`Queue failed (${queueResp.status}): ${body}`);
  }
  const queue = await queueResp.json();
  console.log("fileId:", queue.fileId);
  console.log("protectionId:", queue.protectionId);
  console.log("version:", queue.version);
}

runMusicShield().catch(console.error);

import time
import requests

base = "https://api.artyshield.ai/functions/v1"
headers = {
    "X-API-Key": "USER_API_KEY",
    "apikey": "ANON_KEY",
    "Authorization": "Bearer ANON_KEY",
}

protection_id = "PUT_PROTECTION_ID_HERE"
analysis_requested = True  # set to False if you queued with analysis=False
while True:
    r = requests.get(f"{base}/protections-get/{protection_id}", headers=headers, timeout=60)
    r.raise_for_status()
    data = r.json()
    status = (data.get("status") or "").lower()
    metrics = data.get("protection_metrics") or {}
    analysis = metrics.get("protection_analysis") or {}
    analysis_status = (analysis.get("status") or "").lower() if isinstance(analysis, dict) else ""

    print("status:", status or "unknown", "| analysis_status:", analysis_status or "n/a")

    if status == "failed":
        break
    if status == "completed":
        if not analysis_requested:
            break
        if analysis_status in {"completed", "failed"}:
            break

    time.sleep(4)

if status == "completed":
    print("version:", data.get("version"))
    print("snr_db:", data.get("snr_db"))
    print("protected_download_url:", data.get("protected_download_url"))
    print("noise_footprint_download_url:", data.get("noise_footprint_download_url"))
    if analysis_requested:
        if analysis:
            print("analysis_status:", analysis.get("status"))
            print("analysis_summary:", analysis.get("summary") or analysis.get("text"))
        else:
            print("analysis_status: not_available_yet")
else:
    print("error:", data.get("error_msg"))

const base = "https://api.artyshield.ai/functions/v1";
const headers = {
  "X-API-Key": "USER_API_KEY",
  "apikey": "ANON_KEY",
  "Authorization": "Bearer ANON_KEY",
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollProtection(protectionId, { analysisRequested = true } = {}) {
  while (true) {
    const response = await fetch(`${base}/protections-get/${protectionId}`, { headers });
    if (!response.ok) {
      const body = await response.text();
      throw new Error(`HTTP ${response.status}: ${body}`);
    }
    const data = await response.json();
    const status = String(data.status || "").toLowerCase();
    const metrics = data.protection_metrics || {};
    const analysis = metrics.protection_analysis || {};
    const analysisStatus = String(analysis.status || "").toLowerCase();

    console.log("status:", status || "unknown", "| analysis_status:", analysisStatus || "n/a");

    if (status === "failed") return data;
    if (status === "completed") {
      if (!analysisRequested) return data;
      if (analysisStatus === "completed" || analysisStatus === "failed") return data;
    }

    await sleep(4000);
  }
}

async function run() {
  const protectionId = "PUT_PROTECTION_ID_HERE";
  const analysisRequested = true; // set false if queued with analysis: false
  const data = await pollProtection(protectionId, { analysisRequested });

  if (data.status === "completed") {
    console.log("version:", data.version);
    console.log("snr_db:", data.snr_db);
    console.log("protected_download_url:", data.protected_download_url);
    console.log("noise_footprint_download_url:", data.noise_footprint_download_url);

    if (analysisRequested) {
      const metrics = data.protection_metrics || {};
      const analysis = metrics.protection_analysis || {};
      if (Object.keys(analysis).length) {
        console.log("analysis_status:", analysis.status);
        console.log("analysis_summary:", analysis.summary || analysis.text);
      } else {
        console.log("analysis_status: not_available_yet");
      }
    }
  } else {
    console.log("error:", data.error_msg);
  }
}

run().catch(console.error);