curl -X POST https://api.snapshotarchive.com/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "url": "https://example.com",
    "frequency_minutes": 720,
    "device_type": "desktop",
    "viewport_width": 1920,
    "viewport_height": 1080
  }'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/monitors', [
        'url' => 'https://example.com',
        'frequency_minutes' => 720,
        'device_type' => 'desktop',
        'viewport_width' => 1920,
        'viewport_height' => 1080,
    ]);

$monitor = $response->json('data');

import requests

resp = requests.post('https://api.snapshotarchive.com/v1/monitors',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'url': 'https://example.com', 'frequency_minutes': 720,
          'device_type': 'desktop', 'viewport_width': 1920, 'viewport_height': 1080})

monitor = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/monitors', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ url: 'https://example.com', frequency_minutes: 720,
    device_type: 'desktop', viewport_width: 1920, viewport_height: 1080 }),
});
const { data: monitor } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/monitors')
req = Net::HTTP::Post.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Content-Type' => 'application/json', 'Accept' => 'application/json')
req.body = { url: 'https://example.com', frequency_minutes: 720,
  device_type: 'desktop', viewport_width: 1920, viewport_height: 1080 }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
monitor = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"url":"https://example.com","frequency_minutes":720,
  "device_type":"desktop","viewport_width":1920,"viewport_height":1080}`)
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/monitors", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

# Use the monitor ID returned from step 2 (e.g. 42)
curl -X POST https://api.snapshotarchive.com/v1/monitors/42/trigger \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Response: {"data": {"message": "Snapshot queued successfully.", "snapshot_id": "9e8f7a6b-..."}}

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/monitors/42/trigger');
$snapshot = $response->json('data'); // snapshot_id: "9e8f7a6b-..."

resp = requests.post(f'{BASE}/monitors/42/trigger', headers=headers)
snapshot = resp.json()['data']  # snapshot_id: "9e8f7a6b-..."

const { data } = await fetch(`${BASE}/monitors/42/trigger`, {
  method: 'POST', headers,
}).then(r => r.json()); // snapshot_id: "9e8f7a6b-..."

uri = URI("#{BASE}/monitors/42/trigger")
req = Net::HTTP::Post.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
snapshot = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("POST", BASE+"/monitors/42/trigger", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

# Poll until status is "completed" or "failed"
curl https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-... \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Once completed, download the screenshot
curl -L https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../screenshot \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o screenshot.png

// Poll until status is "completed" or "failed"
$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-...');
$snapshot = $response->json('data');

// Once completed, download the screenshot
$image = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../screenshot');
file_put_contents('screenshot.png', $image->body());

# Poll until status is "completed" or "failed"
resp = requests.get(f'{BASE}/snapshots/9e8f7a6b-...', headers=headers)
snapshot = resp.json()['data']

# Once completed, download the screenshot
img = requests.get(f'{BASE}/snapshots/9e8f7a6b-.../screenshot', headers=headers)
with open('screenshot.png', 'wb') as f:
    f.write(img.content)

// Poll until status is "completed" or "failed"
const { data: snapshot } = await fetch(`${BASE}/snapshots/9e8f7a6b-...`, { headers })
  .then(r => r.json());

// Once completed, download the screenshot
const img = await fetch(`${BASE}/snapshots/9e8f7a6b-.../screenshot`, { headers });
const fs = await import('fs');
fs.writeFileSync('screenshot.png', Buffer.from(await img.arrayBuffer()));

# Poll until status is "completed" or "failed"
uri = URI("#{BASE}/snapshots/9e8f7a6b-...")
req = Net::HTTP::Get.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
snapshot = JSON.parse(resp.body)['data']

# Once completed, download the screenshot
uri = URI("#{BASE}/snapshots/9e8f7a6b-.../screenshot")
req = Net::HTTP::Get.new(uri, headers)
img = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
File.binwrite('screenshot.png', img.body)

// Poll until status is "completed" or "failed"
req, _ := http.NewRequest("GET", BASE+"/snapshots/9e8f7a6b-...", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

// Once completed, download the screenshot
req2, _ := http.NewRequest("GET", BASE+"/snapshots/9e8f7a6b-.../screenshot", nil)
req2.Header.Set("Authorization", "Bearer "+apiKey)
resp2, _ := http.DefaultClient.Do(req2)
defer resp2.Body.Close()
out, _ := os.Create("screenshot.png")
io.Copy(out, resp2.Body)

curl "https://api.snapshotarchive.com/v1/projects" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/projects');
$projects = $response->json('data');

resp = requests.get(f'{BASE}/projects', headers=headers)
projects = resp.json()['data']

const { data: projects } = await fetch(`${BASE}/projects`, { headers })
  .then(r => r.json());

uri = URI("#{BASE}/projects")
req = Net::HTTP::Get.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
projects = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", BASE+"/projects", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

curl -X POST https://api.snapshotarchive.com/v1/projects \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name": "My Website", "description": "Production monitoring"}'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/projects', [
        'name' => 'My Website',
        'description' => 'Production monitoring',
    ]);
$project = $response->json('data');

resp = requests.post(f'{BASE}/projects', headers=headers,
    json={'name': 'My Website', 'description': 'Production monitoring'})
project = resp.json()['data']

const { data: project } = await fetch(`${BASE}/projects`, {
  method: 'POST', headers,
  body: JSON.stringify({ name: 'My Website', description: 'Production monitoring' }),
}).then(r => r.json());

uri = URI("#{BASE}/projects")
req = Net::HTTP::Post.new(uri, headers)
req.body = { name: 'My Website', description: 'Production monitoring' }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
project = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"name":"My Website","description":"Production monitoring"}`)
req, _ := http.NewRequest("POST", BASE+"/projects", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

# Update project name
curl -X PATCH https://api.snapshotarchive.com/v1/projects/1 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name": "Production Sites"}'

$response = Http::withToken('YOUR_API_KEY')
    ->patch('https://api.snapshotarchive.com/v1/projects/1', [
        'name' => 'Production Sites',
    ]);
$project = $response->json('data');

resp = requests.patch(f'{BASE}/projects/1', headers=headers,
    json={'name': 'Production Sites'})
project = resp.json()['data']

const { data: project } = await fetch(`${BASE}/projects/1`, {
  method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' },
  body: JSON.stringify({ name: 'Production Sites' }),
}).then(r => r.json());

uri = URI("#{BASE}/projects/1")
req = Net::HTTP::Patch.new(uri, headers)
req.body = { name: 'Production Sites' }.to_json
req['Content-Type'] = 'application/json'
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
project = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"name":"Production Sites"}`)
req, _ := http.NewRequest("PATCH", BASE+"/projects/1", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl -X DELETE https://api.snapshotarchive.com/v1/projects/1 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/projects/1');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/projects/1',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/projects/1', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uri = URI('https://api.snapshotarchive.com/v1/projects/1')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/projects/1", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

# List active monitors in project 1
curl "https://api.snapshotarchive.com/v1/projects/1/monitors?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/projects/1/monitors', [
        'status' => 'active',
    ]);
$monitors = $response->json('data');

resp = requests.get(f'{BASE}/projects/1/monitors',
    headers=headers, params={'status': 'active'})
monitors = resp.json()['data']

const { data: monitors } = await fetch(
  `${BASE}/projects/1/monitors?status=active`, { headers }
).then(r => r.json());

uri = URI("#{BASE}/projects/1/monitors?status=active")
req = Net::HTTP::Get.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
monitors = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", BASE+"/projects/1/monitors?status=active", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

# List all active monitors
curl "https://api.snapshotarchive.com/v1/monitors?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Search by URL
curl "https://api.snapshotarchive.com/v1/monitors?url=example.com" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors', ['status' => 'active']);

foreach ($response->json('data') as $monitor) {
    echo "{$monitor['id']}: {$monitor['url']} — {$monitor['status']}\n";
}

resp = requests.get(f'{BASE}/monitors', headers=headers, params={'status': 'active'})

for m in resp.json()['data']:
    print(f"{m['id']}: {m['url']} — {m['status']}")

const { data: monitors } = await fetch(`${BASE}/monitors?status=active`, { headers })
  .then(r => r.json());

monitors.forEach(m => console.log(`${m.id}: ${m.url} — ${m.status}`));

uri = URI("#{BASE}/monitors?status=active")
req = Net::HTTP::Get.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
monitors = JSON.parse(resp.body)['data']
monitors.each { |m| puts "#{m['id']}: #{m['url']} — #{m['status']}" }

req, _ := http.NewRequest("GET", BASE+"/monitors?status=active", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result struct { Data []map[string]interface{} `json:"data"` }
json.NewDecoder(resp.Body).Decode(&result)

curl -X POST https://api.snapshotarchive.com/v1/monitors \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "url": "https://example.com",
    "name": "Example Homepage",
    "project_id": 1,
    "frequency_minutes": 360,
    "device_type": "desktop",
    "viewport_width": 1920,
    "viewport_height": 1080,
    "full_page": true,
    "hide_selectors": [".cookie-banner", "#popup"],
    "diff_threshold_percent": 5,
    "alert_enabled": true,
    "alert_email": "[email protected]"
  }'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/monitors', [
        'url' => 'https://example.com',
        'name' => 'Example Homepage',
        'project_id' => 1,
        'frequency_minutes' => 360,
        'device_type' => 'desktop',
        'viewport_width' => 1920,
        'viewport_height' => 1080,
        'full_page' => true,
        'hide_selectors' => ['.cookie-banner', '#popup'],
        'diff_threshold_percent' => 5,
        'alert_enabled' => true,
        'alert_email' => '[email protected]',
    ]);
$monitor = $response->json('data');

resp = requests.post(f'{BASE}/monitors', headers=headers, json={
    'url': 'https://example.com',
    'name': 'Example Homepage',
    'project_id': 1,
    'frequency_minutes': 360,
    'device_type': 'desktop',
    'viewport_width': 1920,
    'viewport_height': 1080,
    'full_page': True,
    'hide_selectors': ['.cookie-banner', '#popup'],
    'diff_threshold_percent': 5,
    'alert_enabled': True,
    'alert_email': '[email protected]',
})
monitor = resp.json()['data']

const { data: monitor } = await fetch(`${BASE}/monitors`, {
  method: 'POST', headers,
  body: JSON.stringify({
    url: 'https://example.com', name: 'Example Homepage',
    project_id: 1, frequency_minutes: 360, device_type: 'desktop',
    viewport_width: 1920, viewport_height: 1080, full_page: true,
    hide_selectors: ['.cookie-banner', '#popup'],
    diff_threshold_percent: 5, alert_enabled: true,
    alert_email: '[email protected]',
  }),
}).then(r => r.json());

uri = URI("#{BASE}/monitors")
req = Net::HTTP::Post.new(uri, headers)
req.body = { url: 'https://example.com', name: 'Example Homepage',
  project_id: 1, frequency_minutes: 360, device_type: 'desktop',
  viewport_width: 1920, viewport_height: 1080, full_page: true,
  hide_selectors: ['.cookie-banner', '#popup'],
  diff_threshold_percent: 5, alert_enabled: true,
  alert_email: '[email protected]' }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
monitor = JSON.parse(resp.body)['data']

payload := map[string]interface{}{
    "url": "https://example.com", "name": "Example Homepage",
    "project_id": 1, "frequency_minutes": 360, "device_type": "desktop",
    "viewport_width": 1920, "viewport_height": 1080, "full_page": true,
    "hide_selectors": []string{".cookie-banner", "#popup"},
    "diff_threshold_percent": 5, "alert_enabled": true,
    "alert_email": "[email protected]",
}
body, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", BASE+"/monitors", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

curl "https://api.snapshotarchive.com/v1/monitors/42" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/monitors/42', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/monitors/42",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/monitors/42", {
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/monitors/42")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/monitors/42", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

# Change frequency and enable full-page capture
curl -X PATCH https://api.snapshotarchive.com/v1/monitors/42 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"frequency_minutes": 360, "full_page": true}'

$client = new \GuzzleHttp\Client();
$response = $client->patch('https://api.snapshotarchive.com/v1/monitors/42', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
        'frequency_minutes' => 360,
        'full_page' => true,
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.patch(
    "https://api.snapshotarchive.com/v1/monitors/42",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
    json={"frequency_minutes": 360, "full_page": True},
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/monitors/42", {
    method: "PATCH",
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({ frequency_minutes: 360, full_page: true }),
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/monitors/42")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = { frequency_minutes: 360, full_page: true }.to_json

response = http.request(request)
data = JSON.parse(response.body)

payload := `{"frequency_minutes": 360, "full_page": true}`
req, _ := http.NewRequest("PATCH", "https://api.snapshotarchive.com/v1/monitors/42", strings.NewReader(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

curl -X DELETE https://api.snapshotarchive.com/v1/monitors/42 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/monitors/42');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/monitors/42',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/monitors/42', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uri = URI('https://api.snapshotarchive.com/v1/monitors/42')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/monitors/42", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

# Async (returns immediately with snapshot_id)
curl -X POST https://api.snapshotarchive.com/v1/monitors/42/trigger \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Sync (waits up to 90s for result)
curl -X POST "https://api.snapshotarchive.com/v1/monitors/42/trigger?wait=true" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/monitors/42/trigger');

$snapshotId = $response->json('data.snapshot_id');

resp = requests.post(f'{BASE}/monitors/42/trigger', headers=headers)
snapshot_id = resp.json()['data']['snapshot_id']

const { data } = await fetch(`${BASE}/monitors/42/trigger`, {
  method: 'POST', headers
}).then(r => r.json());
const snapshotId = data.snapshot_id;

uri = URI("#{BASE}/monitors/42/trigger")
req = Net::HTTP::Post.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
snapshot_id = JSON.parse(resp.body)['data']['snapshot_id']

req, _ := http.NewRequest("POST", BASE+"/monitors/42/trigger", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result struct { Data struct { SnapshotID string `json:"snapshot_id"` } `json:"data"` }
json.NewDecoder(resp.Body).Decode(&result)

# Pause
curl -X POST https://api.snapshotarchive.com/v1/monitors/42/pause \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

# Resume
curl -X POST https://api.snapshotarchive.com/v1/monitors/42/resume \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

$client = new \GuzzleHttp\Client();
$headers = [
    'Authorization' => 'Bearer YOUR_API_KEY',
    'Accept' => 'application/json',
];

// Pause
$response = $client->post('https://api.snapshotarchive.com/v1/monitors/42/pause', [
    'headers' => $headers,
]);

// Resume
$response = $client->post('https://api.snapshotarchive.com/v1/monitors/42/resume', [
    'headers' => $headers,
]);

import requests

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Accept": "application/json",
}

# Pause
requests.post(
    "https://api.snapshotarchive.com/v1/monitors/42/pause",
    headers=headers,
)

# Resume
requests.post(
    "https://api.snapshotarchive.com/v1/monitors/42/resume",
    headers=headers,
)

const headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Accept": "application/json",
};

// Pause
await fetch("https://api.snapshotarchive.com/v1/monitors/42/pause", {
    method: "POST",
    headers,
});

// Resume
await fetch("https://api.snapshotarchive.com/v1/monitors/42/resume", {
    method: "POST",
    headers,
});

require "net/http"

# Pause
uri = URI("https://api.snapshotarchive.com/v1/monitors/42/pause")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"
http.request(request)

# Resume
uri = URI("https://api.snapshotarchive.com/v1/monitors/42/resume")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"
http.request(request)

client := &http.Client{}

// Pause
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/monitors/42/pause", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")
resp, _ := client.Do(req)
resp.Body.Close()

// Resume
req, _ = http.NewRequest("POST", "https://api.snapshotarchive.com/v1/monitors/42/resume", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")
resp, _ = client.Do(req)
resp.Body.Close()

curl -X PUT https://api.snapshotarchive.com/v1/monitors/42/tags \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"tag_ids": [1, 3, 5]}'

$client = new \GuzzleHttp\Client();
$response = $client->put('https://api.snapshotarchive.com/v1/monitors/42/tags', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
        'Content-Type' => 'application/json',
    ],
    'json' => [
        'tag_ids' => [1, 3, 5],
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.put(
    "https://api.snapshotarchive.com/v1/monitors/42/tags",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
    json={"tag_ids": [1, 3, 5]},
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/monitors/42/tags", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({ tag_ids: [1, 3, 5] }),
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/monitors/42/tags")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = { tag_ids: [1, 3, 5] }.to_json

response = http.request(request)
data = JSON.parse(response.body)

payload := `{"tag_ids": [1, 3, 5]}`
req, _ := http.NewRequest("PUT", "https://api.snapshotarchive.com/v1/monitors/42/tags", strings.NewReader(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

# Last week's completed snapshots
curl "https://api.snapshotarchive.com/v1/monitors/42/snapshots?status=completed&captured_after=2026-09-24" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/snapshots', [
        'status' => 'completed',
        'captured_after' => '2026-09-24',
    ]);
$snapshots = $response->json('data');

resp = requests.get(f'{BASE}/monitors/42/snapshots', headers=headers,
    params={'status': 'completed', 'captured_after': '2026-09-24'})
snapshots = resp.json()['data']

const { data: snapshots } = await fetch(
  `${BASE}/monitors/42/snapshots?status=completed&captured_after=2026-09-24`,
  { headers }
).then(r => r.json());

uri = URI("#{BASE}/monitors/42/snapshots?status=completed&captured_after=2026-09-24")
req = Net::HTTP::Get.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
snapshots = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET",
    BASE+"/monitors/42/snapshots?status=completed&captured_after=2026-09-24", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)

curl "https://api.snapshotarchive.com/v1/monitors/42/latest-snapshot" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/monitors/42/latest-snapshot', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/monitors/42/latest-snapshot",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/monitors/42/latest-snapshot", {
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/monitors/42/latest-snapshot")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/monitors/42/latest-snapshot", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

curl "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b", {
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

curl -X DELETE "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uuid = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b'
uri = URI("https://api.snapshotarchive.com/v1/snapshots/#{uuid}")
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

# Download screenshot as PNG
curl -L "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../screenshot" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o screenshot.png

# Download PDF (generated on-the-fly)
curl "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../pdf" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o page.pdf

# Download HTML source
curl -L "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../html" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o source.html

$uuid = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b';

// Download screenshot
$screenshot = Http::withToken('YOUR_API_KEY')
    ->get("https://api.snapshotarchive.com/v1/snapshots/{$uuid}/screenshot");
Storage::put('screenshot.png', $screenshot->body());

// Download PDF (generated on-the-fly)
$pdf = Http::withToken('YOUR_API_KEY')
    ->get("https://api.snapshotarchive.com/v1/snapshots/{$uuid}/pdf");
Storage::put('page.pdf', $pdf->body());

// Download HTML source
$html = Http::withToken('YOUR_API_KEY')
    ->get("https://api.snapshotarchive.com/v1/snapshots/{$uuid}/html");
Storage::put('source.html', $html->body());

uuid = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b'
headers = {'Authorization': 'Bearer YOUR_API_KEY'}

# Download screenshot
r = requests.get(f'https://api.snapshotarchive.com/v1/snapshots/{uuid}/screenshot',
                 headers=headers)
with open('screenshot.png', 'wb') as f:
    f.write(r.content)

# Download PDF (generated on-the-fly)
r = requests.get(f'https://api.snapshotarchive.com/v1/snapshots/{uuid}/pdf',
                 headers=headers)
with open('page.pdf', 'wb') as f:
    f.write(r.content)

# Download HTML source
r = requests.get(f'https://api.snapshotarchive.com/v1/snapshots/{uuid}/html',
                 headers=headers)
with open('source.html', 'wb') as f:
    f.write(r.content)

import fs from 'fs';

const uuid = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b';
const headers = { 'Authorization': 'Bearer YOUR_API_KEY' };
const base = `https://api.snapshotarchive.com/v1/snapshots/${uuid}`;

// Download screenshot
const screenshot = await fetch(`${base}/screenshot`, { headers });
fs.writeFileSync('screenshot.png', Buffer.from(await screenshot.arrayBuffer()));

// Download PDF (generated on-the-fly)
const pdf = await fetch(`${base}/pdf`, { headers });
fs.writeFileSync('page.pdf', Buffer.from(await pdf.arrayBuffer()));

// Download HTML source
const html = await fetch(`${base}/html`, { headers, redirect: 'follow' });
fs.writeFileSync('source.html', Buffer.from(await html.arrayBuffer()));

uuid = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b'

# Download screenshot
uri = URI("https://api.snapshotarchive.com/v1/snapshots/#{uuid}/screenshot")
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
File.binwrite('screenshot.png', res.body)

# Download PDF (generated on-the-fly)
uri = URI("https://api.snapshotarchive.com/v1/snapshots/#{uuid}/pdf")
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
File.binwrite('page.pdf', res.body)

uuid := "9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b"
base := "https://api.snapshotarchive.com/v1/snapshots/" + uuid

// Download screenshot
req, _ := http.NewRequest("GET", base+"/screenshot", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
data, _ := io.ReadAll(resp.Body)
os.WriteFile("screenshot.png", data, 0644)

// Download PDF (generated on-the-fly)
req, _ = http.NewRequest("GET", base+"/pdf", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ = http.DefaultClient.Do(req)
defer resp.Body.Close()
data, _ = io.ReadAll(resp.Body)
os.WriteFile("page.pdf", data, 0644)

curl -X POST "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share');
$shareUrl = $response->json('data.share_url');

response = requests.post(
    'https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)
share_url = response.json()['data']['share_url']

const response = await fetch('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});
const { share_url } = (await response.json()).data;

uri = URI('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
share_url = JSON.parse(res.body).dig('data', 'share_url')

req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
// Parse response JSON for data.share_url

curl -X DELETE "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b/share" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uri = URI('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../share", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

curl -X POST "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../forward" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]"}'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../forward', [
        'email' => '[email protected]',
    ]);

response = requests.post(
    'https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../forward',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    json={'email': '[email protected]'}
)

const response = await fetch('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../forward', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email: '[email protected]' })
});

uri = URI('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../forward')
req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
req['Authorization'] = 'Bearer YOUR_API_KEY'
req.body = { email: '[email protected]' }.to_json
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

body := strings.NewReader(`{"email":"[email protected]"}`)
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../forward", body)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

# Export last month's screenshots + PDFs
curl -X POST "https://api.snapshotarchive.com/v1/monitors/42/export" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d "captured_after=2026-09-01&captured_before=2026-09-30&include=screenshot,pdf" \
  -o export.zip

$client = new \GuzzleHttp\Client();
$response = $client->post('https://api.snapshotarchive.com/v1/monitors/42/export', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
    ],
    'form_params' => [
        'captured_after' => '2026-09-01',
        'captured_before' => '2026-09-30',
        'include' => 'screenshot,pdf',
    ],
    'sink' => 'export.zip',
]);
// Check X-Export-Snapshot-Count and X-Export-File-Count headers

import requests

response = requests.post(
    "https://api.snapshotarchive.com/v1/monitors/42/export",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    data={
        "captured_after": "2026-09-01",
        "captured_before": "2026-09-30",
        "include": "screenshot,pdf",
    },
    stream=True,
)
with open("export.zip", "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

const response = await fetch("https://api.snapshotarchive.com/v1/monitors/42/export", {
    method: "POST",
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/x-www-form-urlencoded",
    },
    body: "captured_after=2026-09-01&captured_before=2026-09-30&include=screenshot,pdf",
});
const blob = await response.blob();
// Save blob to file

require "net/http"

uri = URI("https://api.snapshotarchive.com/v1/monitors/42/export")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request.set_form_data(
  "captured_after" => "2026-09-01",
  "captured_before" => "2026-09-30",
  "include" => "screenshot,pdf"
)

response = http.request(request)
File.open("export.zip", "wb") { |f| f.write(response.body) }

data := url.Values{
    "captured_after":  {"2026-09-01"},
    "captured_before": {"2026-09-30"},
    "include":         {"screenshot,pdf"},
}
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/monitors/42/export",
    strings.NewReader(data.Encode()))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

out, _ := os.Create("export.zip")
defer out.Close()
io.Copy(out, resp.Body)

curl -L "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../package" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o snapshot-package.zip

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../package', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
    ],
    'sink' => 'snapshot-package.zip',
]);

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../package",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    stream=True,
)
with open("snapshot-package.zip", "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

const response = await fetch("https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../package", {
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
    },
});
const blob = await response.blob();
// Save blob to file

require "net/http"

uri = URI("https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../package")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = http.request(request)
File.open("snapshot-package.zip", "wb") { |f| f.write(response.body) }

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-.../package", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

out, _ := os.Create("snapshot-package.zip")
defer out.Close()
io.Copy(out, resp.Body)

# Get significant changes only
curl "https://api.snapshotarchive.com/v1/monitors/42/diffs?is_significant=true" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/monitors/42/diffs', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
    'query' => [
        'is_significant' => 'true',
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/monitors/42/diffs",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
    params={"is_significant": "true"},
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/monitors/42/diffs?is_significant=true", {
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/monitors/42/diffs?is_significant=true")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/monitors/42/diffs?is_significant=true", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

curl "https://api.snapshotarchive.com/v1/diffs/15" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/diffs/15', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
]);
$data = json_decode($response->getBody(), true);

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/diffs/15",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
)
data = response.json()

const response = await fetch("https://api.snapshotarchive.com/v1/diffs/15", {
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
});
const data = await response.json();

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/diffs/15")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/diffs/15", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

curl "https://api.snapshotarchive.com/v1/tags" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/tags');
$tags = $response->json('data');

resp = requests.get('https://api.snapshotarchive.com/v1/tags',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})
tags = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/tags', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' }
});
const { data: tags } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/tags')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Accept'] = 'application/json'
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
tags = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/tags", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl -X POST https://api.snapshotarchive.com/v1/tags \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name": "Production", "color": "#FF0000"}'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/tags', [
        'name' => 'Production',
        'color' => '#FF0000',
    ]);
$tag = $response->json('data');

resp = requests.post('https://api.snapshotarchive.com/v1/tags',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'name': 'Production', 'color': '#FF0000'})
tag = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/tags', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ name: 'Production', color: '#FF0000' }),
});
const { data: tag } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/tags')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Content-Type'] = 'application/json'
req['Accept'] = 'application/json'
req.body = { name: 'Production', color: '#FF0000' }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
tag = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"name":"Production","color":"#FF0000"}`)
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/tags", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl -X DELETE https://api.snapshotarchive.com/v1/tags/1 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/tags/1');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/tags/1',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/tags/1', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uri = URI('https://api.snapshotarchive.com/v1/tags/1')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/tags/1", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

# Update tag color
curl -X PUT https://api.snapshotarchive.com/v1/tags/1 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"color": "#00FF00"}'

# Delete tag
curl -X DELETE https://api.snapshotarchive.com/v1/tags/1 \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

// Update tag color
$response = Http::withToken('YOUR_API_KEY')
    ->put('https://api.snapshotarchive.com/v1/tags/1', [
        'color' => '#00FF00',
    ]);
$tag = $response->json('data');

# Update tag color
resp = requests.put('https://api.snapshotarchive.com/v1/tags/1',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'color': '#00FF00'})
tag = resp.json()['data']

// Update tag color
const resp = await fetch('https://api.snapshotarchive.com/v1/tags/1', {
  method: 'PUT',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ color: '#00FF00' }),
});
const { data: tag } = await resp.json();

# Update tag color
uri = URI('https://api.snapshotarchive.com/v1/tags/1')
req = Net::HTTP::Put.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Content-Type'] = 'application/json'
req['Accept'] = 'application/json'
req.body = { color: '#00FF00' }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
tag = JSON.parse(resp.body)['data']

// Update tag color
body := strings.NewReader(`{"color":"#00FF00"}`)
req, _ := http.NewRequest("PUT", "https://api.snapshotarchive.com/v1/tags/1", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl "https://api.snapshotarchive.com/v1/webhooks" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/webhooks');
$webhooks = $response->json('data');

resp = requests.get('https://api.snapshotarchive.com/v1/webhooks',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})
webhooks = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/webhooks', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' }
});
const { data: webhooks } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/webhooks')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Accept'] = 'application/json'
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
webhooks = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/webhooks", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl -X POST https://api.snapshotarchive.com/v1/webhooks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "url": "https://example.com/webhook",
    "events": ["snapshot.completed", "snapshot.failed", "diff.completed"],
    "description": "Capture notifications"
  }'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/webhooks', [
        'url' => 'https://example.com/webhook',
        'events' => ['snapshot.completed', 'snapshot.failed', 'diff.completed'],
        'description' => 'Capture notifications',
    ]);
$webhook = $response->json('data');

resp = requests.post('https://api.snapshotarchive.com/v1/webhooks',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'url': 'https://example.com/webhook',
          'events': ['snapshot.completed', 'snapshot.failed', 'diff.completed'],
          'description': 'Capture notifications'})
webhook = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/webhooks', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({
    url: 'https://example.com/webhook',
    events: ['snapshot.completed', 'snapshot.failed', 'diff.completed'],
    description: 'Capture notifications',
  }),
});
const { data: webhook } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/webhooks')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Content-Type'] = 'application/json'
req['Accept'] = 'application/json'
req.body = { url: 'https://example.com/webhook',
  events: ['snapshot.completed', 'snapshot.failed', 'diff.completed'],
  description: 'Capture notifications' }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
webhook = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"url":"https://example.com/webhook",
  "events":["snapshot.completed","snapshot.failed","diff.completed"],
  "description":"Capture notifications"}`)
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/webhooks", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

# Pause a webhook
curl -X PUT https://api.snapshotarchive.com/v1/webhooks/1 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"is_active": false}'

// Pause a webhook
$response = Http::withToken('YOUR_API_KEY')
    ->put('https://api.snapshotarchive.com/v1/webhooks/1', [
        'is_active' => false,
    ]);
$webhook = $response->json('data');

# Pause a webhook
resp = requests.put('https://api.snapshotarchive.com/v1/webhooks/1',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'is_active': False})
webhook = resp.json()['data']

// Pause a webhook
const resp = await fetch('https://api.snapshotarchive.com/v1/webhooks/1', {
  method: 'PUT',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ is_active: false }),
});
const { data: webhook } = await resp.json();

# Pause a webhook
uri = URI('https://api.snapshotarchive.com/v1/webhooks/1')
req = Net::HTTP::Put.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Content-Type'] = 'application/json'
req['Accept'] = 'application/json'
req.body = { is_active: false }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
webhook = JSON.parse(resp.body)['data']

// Pause a webhook
body := strings.NewReader(`{"is_active":false}`)
req, _ := http.NewRequest("PUT", "https://api.snapshotarchive.com/v1/webhooks/1", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl -X DELETE https://api.snapshotarchive.com/v1/webhooks/1 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/webhooks/1');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/webhooks/1',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/webhooks/1', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uri = URI('https://api.snapshotarchive.com/v1/webhooks/1')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/webhooks/1", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

curl -X POST https://api.snapshotarchive.com/v1/webhooks/1/rotate-secret \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Response: {"data": {"secret": "new-secret-here..."}}

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/webhooks/1/rotate-secret');
$newSecret = $response->json('data.secret');

resp = requests.post('https://api.snapshotarchive.com/v1/webhooks/1/rotate-secret',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})
new_secret = resp.json()['data']['secret']

const resp = await fetch('https://api.snapshotarchive.com/v1/webhooks/1/rotate-secret', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' }
});
const { data: { secret } } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/webhooks/1/rotate-secret')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Accept'] = 'application/json'
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
new_secret = JSON.parse(resp.body).dig('data', 'secret')

req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/webhooks/1/rotate-secret", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl -X POST https://api.snapshotarchive.com/v1/webhooks/1/test \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Response: {"data": {"message": "Test webhook delivered successfully.", "status": 200}}

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/webhooks/1/test');
$result = $response->json('data'); // message + status

resp = requests.post('https://api.snapshotarchive.com/v1/webhooks/1/test',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})
result = resp.json()['data']  # message + status

const resp = await fetch('https://api.snapshotarchive.com/v1/webhooks/1/test', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' }
});
const { data: result } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/webhooks/1/test')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Accept'] = 'application/json'
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
result = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/webhooks/1/test", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

# View failed deliveries
curl "https://api.snapshotarchive.com/v1/webhooks/1/deliveries?delivered=false" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/webhooks/1/deliveries', [
        'delivered' => false,
    ]);
$deliveries = $response->json('data');

resp = requests.get('https://api.snapshotarchive.com/v1/webhooks/1/deliveries',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    params={'delivered': 'false'})
deliveries = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/webhooks/1/deliveries?delivered=false', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' }
});
const { data: deliveries } = await resp.json();

uri = URI('https://api.snapshotarchive.com/v1/webhooks/1/deliveries?delivered=false')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
req['Accept'] = 'application/json'
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
deliveries = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/webhooks/1/deliveries?delivered=false", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

curl "https://api.snapshotarchive.com/v1/account" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/account');

$account = $response->json('data');

import requests

resp = requests.get('https://api.snapshotarchive.com/v1/account',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})

account = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/account', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' },
});
const { data: account } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/account')
req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
account = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/account", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

curl "https://api.snapshotarchive.com/v1/account/usage" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/account/usage');

$usage = $response->json('data');

import requests

resp = requests.get('https://api.snapshotarchive.com/v1/account/usage',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})

usage = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/account/usage', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' },
});
const { data: usage } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/account/usage')
req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
usage = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/account/usage", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

curl "https://api.snapshotarchive.com/v1/api-keys" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/api-keys');

$keys = $response->json('data');

import requests

resp = requests.get('https://api.snapshotarchive.com/v1/api-keys',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'})

keys = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/api-keys', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' },
});
const { data: keys } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/api-keys')
req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
keys = JSON.parse(resp.body)['data']

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/api-keys", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

curl -X POST https://api.snapshotarchive.com/v1/api-keys \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "CI/CD Pipeline",
    "allowed_ips": ["203.0.113.10"],
    "expires_at": "2027-12-31T23:59:59Z"
  }'

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/api-keys', [
        'name' => 'CI/CD Pipeline',
        'allowed_ips' => ['203.0.113.10'],
        'expires_at' => '2027-12-31T23:59:59Z',
    ]);

$data = $response->json('data');
$token = $data['token']; // Save this immediately!

import requests

resp = requests.post('https://api.snapshotarchive.com/v1/api-keys',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'name': 'CI/CD Pipeline', 'allowed_ips': ['203.0.113.10'],
          'expires_at': '2027-12-31T23:59:59Z'})

data = resp.json()['data']
token = data['token']  # Save this immediately!

const resp = await fetch('https://api.snapshotarchive.com/v1/api-keys', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ name: 'CI/CD Pipeline',
    allowed_ips: ['203.0.113.10'], expires_at: '2027-12-31T23:59:59Z' }),
});
const { data } = await resp.json();
console.log(data.token); // Save this immediately!

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/api-keys')
req = Net::HTTP::Post.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Content-Type' => 'application/json', 'Accept' => 'application/json')
req.body = { name: 'CI/CD Pipeline', allowed_ips: ['203.0.113.10'],
  expires_at: '2027-12-31T23:59:59Z' }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)['data']
puts data['token'] # Save this immediately!

body := strings.NewReader(`{"name":"CI/CD Pipeline",
  "allowed_ips":["203.0.113.10"],"expires_at":"2027-12-31T23:59:59Z"}`)
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/api-keys", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

# Add IP restriction
curl -X PUT https://api.snapshotarchive.com/v1/api-keys/2 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"allowed_ips": ["203.0.113.10", "198.51.100.20"]}'

$response = Http::withToken('YOUR_API_KEY')
    ->put('https://api.snapshotarchive.com/v1/api-keys/2', [
        'allowed_ips' => ['203.0.113.10', '198.51.100.20'],
    ]);

$key = $response->json('data');

import requests

resp = requests.put('https://api.snapshotarchive.com/v1/api-keys/2',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'allowed_ips': ['203.0.113.10', '198.51.100.20']})

key = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/api-keys/2', {
  method: 'PUT',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ allowed_ips: ['203.0.113.10', '198.51.100.20'] }),
});
const { data: key } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/api-keys/2')
req = Net::HTTP::Put.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Content-Type' => 'application/json', 'Accept' => 'application/json')
req.body = { allowed_ips: ['203.0.113.10', '198.51.100.20'] }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
key = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"allowed_ips":["203.0.113.10","198.51.100.20"]}`)
req, _ := http.NewRequest("PUT", "https://api.snapshotarchive.com/v1/api-keys/2", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

curl -X DELETE https://api.snapshotarchive.com/v1/api-keys/5 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->delete('https://api.snapshotarchive.com/v1/api-keys/5');
// 204 No Content

response = requests.delete(
    'https://api.snapshotarchive.com/v1/api-keys/5',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)  # 204 No Content

const response = await fetch('https://api.snapshotarchive.com/v1/api-keys/5', {
    method: 'DELETE',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}); // 204 No Content

uri = URI('https://api.snapshotarchive.com/v1/api-keys/5')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer YOUR_API_KEY'
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
# 204 No Content

req, _ := http.NewRequest("DELETE", "https://api.snapshotarchive.com/v1/api-keys/5", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
resp, _ := http.DefaultClient.Do(req)
// 204 No Content

# Snapshots from September 2026
curl "https://api.snapshotarchive.com/v1/monitors/42/snapshots?captured_after=2026-09-01&captured_before=2026-09-30" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

# Only completed snapshots, oldest first
curl "https://api.snapshotarchive.com/v1/monitors/42/snapshots?status=completed&sort=captured_at&order=asc" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

# Diffs with more than 5% visual change
curl "https://api.snapshotarchive.com/v1/monitors/42/diffs?min_change_percent=5&sort=change_percent&order=desc" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

// Snapshots from September 2026
$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/snapshots', [
        'captured_after' => '2026-09-01',
        'captured_before' => '2026-09-30',
    ]);

// Only completed snapshots, oldest first
$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/snapshots', [
        'status' => 'completed',
        'sort' => 'captured_at',
        'order' => 'asc',
    ]);

// Diffs with more than 5% visual change
$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/diffs', [
        'min_change_percent' => 5,
        'sort' => 'change_percent',
        'order' => 'desc',
    ]);

import requests

headers = {'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'}

# Snapshots from September 2026
resp = requests.get('https://api.snapshotarchive.com/v1/monitors/42/snapshots',
    headers=headers, params={'captured_after': '2026-09-01', 'captured_before': '2026-09-30'})

# Only completed snapshots, oldest first
resp = requests.get('https://api.snapshotarchive.com/v1/monitors/42/snapshots',
    headers=headers, params={'status': 'completed', 'sort': 'captured_at', 'order': 'asc'})

# Diffs with more than 5% visual change
resp = requests.get('https://api.snapshotarchive.com/v1/monitors/42/diffs',
    headers=headers, params={'min_change_percent': 5, 'sort': 'change_percent', 'order': 'desc'})

const headers = { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' };

// Snapshots from September 2026
const resp1 = await fetch(
  'https://api.snapshotarchive.com/v1/monitors/42/snapshots?captured_after=2026-09-01&captured_before=2026-09-30',
  { headers });

// Only completed snapshots, oldest first
const resp2 = await fetch(
  'https://api.snapshotarchive.com/v1/monitors/42/snapshots?status=completed&sort=captured_at&order=asc',
  { headers });

// Diffs with more than 5% visual change
const resp3 = await fetch(
  'https://api.snapshotarchive.com/v1/monitors/42/diffs?min_change_percent=5&sort=change_percent&order=desc',
  { headers });

require 'net/http'
require 'json'

# Snapshots from September 2026
uri = URI('https://api.snapshotarchive.com/v1/monitors/42/snapshots?captured_after=2026-09-01&captured_before=2026-09-30')
req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
snapshots = JSON.parse(resp.body)['data']

// Snapshots from September 2026
req, _ := http.NewRequest("GET",
    "https://api.snapshotarchive.com/v1/monitors/42/snapshots?captured_after=2026-09-01&captured_before=2026-09-30", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

# Get page 3 with 50 items per page
curl "https://api.snapshotarchive.com/v1/monitors?page=3&per_page=50" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors', [
        'page' => 3,
        'per_page' => 50,
    ]);

$monitors = $response->json('data');
$meta = $response->json('meta');

import requests

resp = requests.get('https://api.snapshotarchive.com/v1/monitors',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    params={'page': 3, 'per_page': 50})

data = resp.json()
monitors = data['data']
meta = data['meta']

const resp = await fetch('https://api.snapshotarchive.com/v1/monitors?page=3&per_page=50', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' },
});
const { data: monitors, meta } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/monitors?page=3&per_page=50')
req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
result = JSON.parse(resp.body)
monitors = result['data']
meta = result['meta']

req, _ := http.NewRequest("GET",
    "https://api.snapshotarchive.com/v1/monitors?page=3&per_page=50", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

# Quick health check — no API key needed
curl -s https://api.snapshotarchive.com/v1/status | jq .status
# "operational"

$response = Http::get('https://api.snapshotarchive.com/v1/status');

$status = $response->json('status'); // "operational"

import requests

resp = requests.get('https://api.snapshotarchive.com/v1/status',
    headers={'Accept': 'application/json'})

print(resp.json()['status'])  # "operational"

const resp = await fetch('https://api.snapshotarchive.com/v1/status', {
  headers: { 'Accept': 'application/json' },
});
const { status } = await resp.json();
console.log(status); // "operational"

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/status')
req = Net::HTTP::Get.new(uri, 'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
puts JSON.parse(resp.body)['status'] # "operational"

req, _ := http.NewRequest("GET", "https://api.snapshotarchive.com/v1/status", nil)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result["status"]) // "operational"

curl "https://api.snapshotarchive.com/v1/monitors?url=example.com" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"
# Response: "data": [{"id": 42, ...}]

$client = new \GuzzleHttp\Client();
$response = $client->get('https://api.snapshotarchive.com/v1/monitors', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Accept' => 'application/json',
    ],
    'query' => ['url' => 'example.com'],
]);
$data = json_decode($response->getBody(), true);
// $data['data'][0]['id'] => 42

import requests

response = requests.get(
    "https://api.snapshotarchive.com/v1/monitors",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/json",
    },
    params={"url": "example.com"},
)
data = response.json()
# data["data"][0]["id"] => 42

const response = await fetch(
    "https://api.snapshotarchive.com/v1/monitors?url=example.com",
    {
        headers: {
            "Authorization": "Bearer YOUR_API_KEY",
            "Accept": "application/json",
        },
    }
);
const data = await response.json();
// data.data[0].id => 42

require "net/http"
require "json"

uri = URI("https://api.snapshotarchive.com/v1/monitors?url=example.com")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/json"

response = http.request(request)
data = JSON.parse(response.body)
# data["data"][0]["id"] => 42

req, _ := http.NewRequest("GET",
    "https://api.snapshotarchive.com/v1/monitors?url=example.com", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Accept", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
// Parse JSON to find monitor ID

# Get the latest snapshot on or before September 5
curl "https://api.snapshotarchive.com/v1/monitors/42/snapshots?captured_before=2026-09-05T23:59:59Z&status=completed&per_page=1" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

# Download using the snapshot UUID from the response
curl -L "https://api.snapshotarchive.com/v1/snapshots/SNAPSHOT_UUID/screenshot" \
  -H "Authorization: Bearer YOUR_API_KEY" -o screenshot-sept5.png

$snapshots = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/snapshots', [
        'captured_before' => '2026-09-05T23:59:59Z',
        'status' => 'completed',
        'per_page' => 1,
    ])->json('data');

if (count($snapshots) > 0) {
    $screenshotUrl = $snapshots[0]['files']['screenshot_url'];
}

resp = requests.get(f'{BASE}/monitors/42/snapshots', headers=headers,
    params={'captured_before': '2026-09-05T23:59:59Z', 'status': 'completed', 'per_page': 1})
snapshots = resp.json()['data']

if snapshots:
    img = requests.get(snapshots[0]['files']['screenshot_url'])
    with open('screenshot-sept5.png', 'wb') as f:
        f.write(img.content)

const { data: snapshots } = await fetch(
  `${BASE}/monitors/42/snapshots?captured_before=2026-09-05T23:59:59Z&status=completed&per_page=1`,
  { headers }
).then(r => r.json());

if (snapshots.length > 0) {
  const img = await fetch(snapshots[0].files.screenshot_url);
  // save or display the image
}

uri = URI("#{BASE}/monitors/42/snapshots?captured_before=2026-09-05T23:59:59Z&status=completed&per_page=1")
req = Net::HTTP::Get.new(uri, headers)
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
snapshots = JSON.parse(resp.body)['data']
puts snapshots.first['files']['screenshot_url'] if snapshots.any?

req, _ := http.NewRequest("GET",
    BASE+"/monitors/42/snapshots?captured_before=2026-09-05T23:59:59Z&status=completed&per_page=1", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
resp, _ := http.DefaultClient.Do(req)
// parse response and use files.screenshot_url

# Significant diffs in the past 7 days, sorted by change %
curl "https://api.snapshotarchive.com/v1/monitors/42/diffs?created_after=2026-09-24&is_significant=true&sort=change_percent&order=desc" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

# Only large changes (>10%)
curl "https://api.snapshotarchive.com/v1/monitors/42/diffs?min_change_percent=10" \
  -H "Authorization: Bearer YOUR_API_KEY" -H "Accept: application/json"

// Significant diffs in the past 7 days
$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/diffs', [
        'created_after' => '2026-09-24',
        'is_significant' => true,
        'sort' => 'change_percent',
        'order' => 'desc',
    ]);

// Only large changes (>10%)
$response = Http::withToken('YOUR_API_KEY')
    ->get('https://api.snapshotarchive.com/v1/monitors/42/diffs', [
        'min_change_percent' => 10,
    ]);

import requests

headers = {'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'}

# Significant diffs in the past 7 days
resp = requests.get('https://api.snapshotarchive.com/v1/monitors/42/diffs',
    headers=headers, params={'created_after': '2026-09-24', 'is_significant': True,
                             'sort': 'change_percent', 'order': 'desc'})

# Only large changes (>10%)
resp = requests.get('https://api.snapshotarchive.com/v1/monitors/42/diffs',
    headers=headers, params={'min_change_percent': 10})

const headers = { 'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json' };

// Significant diffs in the past 7 days
const resp = await fetch(
  'https://api.snapshotarchive.com/v1/monitors/42/diffs?created_after=2026-09-24&is_significant=true&sort=change_percent&order=desc',
  { headers });

// Only large changes (>10%)
const resp2 = await fetch(
  'https://api.snapshotarchive.com/v1/monitors/42/diffs?min_change_percent=10',
  { headers });

require 'net/http'
require 'json'

# Significant diffs in the past 7 days
uri = URI('https://api.snapshotarchive.com/v1/monitors/42/diffs?created_after=2026-09-24&is_significant=true&sort=change_percent&order=desc')
req = Net::HTTP::Get.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Accept' => 'application/json')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
diffs = JSON.parse(resp.body)['data']

// Significant diffs in the past 7 days
req, _ := http.NewRequest("GET",
    "https://api.snapshotarchive.com/v1/monitors/42/diffs?created_after=2026-09-24&is_significant=true&sort=change_percent&order=desc", nil)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Accept", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

# Export all September screenshots as ZIP (fastest method)
curl -X POST "https://api.snapshotarchive.com/v1/monitors/42/export" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d "captured_after=2026-09-01&captured_before=2026-09-30&include=screenshot" \
  -o september-screenshots.zip

$response = Http::withToken('YOUR_API_KEY')
    ->post('https://api.snapshotarchive.com/v1/monitors/42/export', [
        'captured_after' => '2026-09-01',
        'captured_before' => '2026-09-30',
        'include' => 'screenshot',
    ]);

file_put_contents('september-screenshots.zip', $response->body());

import requests

resp = requests.post('https://api.snapshotarchive.com/v1/monitors/42/export',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    data={'captured_after': '2026-09-01', 'captured_before': '2026-09-30',
          'include': 'screenshot'})

with open('september-screenshots.zip', 'wb') as f:
    f.write(resp.content)

const resp = await fetch('https://api.snapshotarchive.com/v1/monitors/42/export', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/x-www-form-urlencoded' },
  body: 'captured_after=2026-09-01&captured_before=2026-09-30&include=screenshot',
});
const blob = await resp.blob();
// save blob as september-screenshots.zip

require 'net/http'

uri = URI('https://api.snapshotarchive.com/v1/monitors/42/export')
req = Net::HTTP::Post.new(uri, 'Authorization' => "Bearer #{API_KEY}")
req.set_form_data('captured_after' => '2026-09-01',
  'captured_before' => '2026-09-30', 'include' => 'screenshot')
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
File.write('september-screenshots.zip', resp.body)

body := strings.NewReader("captured_after=2026-09-01&captured_before=2026-09-30&include=screenshot")
req, _ := http.NewRequest("POST", "https://api.snapshotarchive.com/v1/monitors/42/export", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
out, _ := os.Create("september-screenshots.zip")
io.Copy(out, resp.Body)

curl -X PATCH "https://api.snapshotarchive.com/v1/monitors/42" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" -H "Accept: application/json" \
  -d '{
    "alert_enabled": true,
    "alert_webhook_url": "https://your-server.com/webhooks/screenshot-change",
    "diff_enabled": true,
    "diff_threshold_percent": 5
  }'

$response = Http::withToken('YOUR_API_KEY')
    ->patch('https://api.snapshotarchive.com/v1/monitors/42', [
        'alert_enabled' => true,
        'alert_webhook_url' => 'https://your-server.com/webhooks/screenshot-change',
        'diff_enabled' => true,
        'diff_threshold_percent' => 5,
    ]);

$monitor = $response->json('data');

import requests

resp = requests.patch('https://api.snapshotarchive.com/v1/monitors/42',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'alert_enabled': True,
          'alert_webhook_url': 'https://your-server.com/webhooks/screenshot-change',
          'diff_enabled': True, 'diff_threshold_percent': 5})

monitor = resp.json()['data']

const resp = await fetch('https://api.snapshotarchive.com/v1/monitors/42', {
  method: 'PATCH',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY',
             'Content-Type': 'application/json', 'Accept': 'application/json' },
  body: JSON.stringify({ alert_enabled: true,
    alert_webhook_url: 'https://your-server.com/webhooks/screenshot-change',
    diff_enabled: true, diff_threshold_percent: 5 }),
});
const { data: monitor } = await resp.json();

require 'net/http'
require 'json'

uri = URI('https://api.snapshotarchive.com/v1/monitors/42')
req = Net::HTTP::Patch.new(uri, 'Authorization' => "Bearer #{API_KEY}",
  'Content-Type' => 'application/json', 'Accept' => 'application/json')
req.body = { alert_enabled: true,
  alert_webhook_url: 'https://your-server.com/webhooks/screenshot-change',
  diff_enabled: true, diff_threshold_percent: 5 }.to_json
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
monitor = JSON.parse(resp.body)['data']

body := strings.NewReader(`{"alert_enabled":true,
  "alert_webhook_url":"https://your-server.com/webhooks/screenshot-change",
  "diff_enabled":true,"diff_threshold_percent":5}`)
req, _ := http.NewRequest("PATCH", "https://api.snapshotarchive.com/v1/monitors/42", body)
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)