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

response = 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 = response.json()['data']

const response = 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 response.json();

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

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

for project in projects['data']:
    print(f"ID: {project['id']} | {project['name']} | {project['monitors_count']} monitors")

# Use the project ID to filter monitors
project_id = projects['data'][0]['id']

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

projects.forEach(p => {
  console.log(`ID: ${p.id} | ${p.name} | ${p.monitors_count} monitors`);
});

// Use the project ID to filter monitors
const projectId = projects[0].id;

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');

response = requests.post(
    'https://api.snapshotarchive.com/v1/projects',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    json={'name': 'My Website', 'description': 'Production monitoring'}
)

project = response.json()['data']

const response = await fetch('https://api.snapshotarchive.com/v1/projects', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  },
  body: JSON.stringify({
    name: 'My Website',
    description: 'Production monitoring',
  }),
});

const { data: project } = await response.json();

# 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"

import requests

API_KEY = 'YOUR_API_KEY'
BASE = 'https://api.snapshotarchive.com/v1'
headers = {'Authorization': f'Bearer {API_KEY}', 'Accept': 'application/json'}

# List monitors
response = requests.get(f'{BASE}/monitors', headers=headers, params={'status': 'active'})
monitors = response.json()

# Access the data
for monitor in monitors['data']:
    print(f"ID: {monitor['id']} | {monitor['url']} | Status: {monitor['status']}")

# Get a specific monitor's ID for use in other endpoints
monitor_id = monitors['data'][0]['id']  # e.g. 42
print(f"\nUse this ID for snapshots: GET /v1/monitors/{monitor_id}/snapshots")

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://api.snapshotarchive.com/v1';
const headers = { 'Authorization': `Bearer ${API_KEY}`, 'Accept': 'application/json' };

// List monitors
const res = await fetch(`${BASE}/monitors?status=active`, { headers });
const { data: monitors, meta } = await res.json();

// Access the data
monitors.forEach(m => {
  console.log(`ID: ${m.id} | ${m.url} | Status: ${m.status}`);
});

// Get a specific monitor's ID for use in other endpoints
const monitorId = monitors[0].id; // e.g. 42
console.log(`\nUse this ID for snapshots: GET /v1/monitors/${monitorId}/snapshots`);

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": 30,
    "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' => 30,
        'alert_enabled' => true,
        'alert_email' => '[email protected]',
    ]);

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

response = requests.post(
    'https://api.snapshotarchive.com/v1/monitors',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Accept': 'application/json'},
    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': 30,
        'alert_enabled': True,
        'alert_email': '[email protected]',
    }
)

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

const response = 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',
    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: 30,
    alert_enabled: true,
    alert_email: '[email protected]',
  }),
});

const { data: monitor } = await response.json();

# List snapshots for monitor 42 (get monitor ID from GET /v1/monitors)
curl "https://api.snapshotarchive.com/v1/monitors/42/snapshots?status=completed&captured_after=2026-09-01" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Get monitor ID first, then list its snapshots
monitors = requests.get(f'{BASE}/monitors', headers=headers, params={'url': 'example.com'}).json()
monitor_id = monitors['data'][0]['id']  # e.g. 42

snapshots = requests.get(
    f'{BASE}/monitors/{monitor_id}/snapshots',
    headers=headers,
    params={'status': 'completed', 'captured_after': '2026-09-01'}
).json()

for snap in snapshots['data']:
    print(f"{snap['id'][:8]}... | {snap['captured_at']} | HTTP {snap['http_status']}")

// Get monitor ID first, then list its snapshots
const monitors = await fetch(`${BASE}/monitors?url=example.com`, { headers }).then(r => r.json());
const monitorId = monitors.data[0].id; // e.g. 42

const params = new URLSearchParams({ status: 'completed', captured_after: '2026-09-01' });
const { data: snapshots } = await fetch(
  `${BASE}/monitors/${monitorId}/snapshots?${params}`, { headers }
).then(r => r.json());

snapshots.forEach(s => {
  console.log(`${s.id.slice(0, 8)}... | ${s.captured_at} | HTTP ${s.http_status}`);
});

# Use the snapshot UUID from trigger response or snapshots list
curl "https://api.snapshotarchive.com/v1/snapshots/9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Get snapshot details with download URLs
snapshot_uuid = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b'  # from trigger or list
snapshot = requests.get(f'{BASE}/snapshots/{snapshot_uuid}', headers=headers).json()['data']

# Download the screenshot
if snapshot['files']['screenshot_url']:
    img = requests.get(snapshot['files']['screenshot_url'])
    with open('screenshot.png', 'wb') as f:
        f.write(img.content)

// Get snapshot details with download URLs
const snapshotId = '9e8f7a6b-5c4d-3e2f-1a0b-9c8d7e6f5a4b'; // from trigger or list
const { data: snapshot } = await fetch(`${BASE}/snapshots/${snapshotId}`, { headers })
  .then(r => r.json());

console.log(`Status: ${snapshot.status}`);
console.log(`Screenshot: ${snapshot.files.screenshot_url}`);

#!/bin/bash
# Trigger snapshot
RESPONSE=$(curl -s -X POST https://api.snapshotarchive.com/v1/monitors/42/trigger \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json")

SNAPSHOT_ID=$(echo $RESPONSE | jq -r '.data.snapshot_id')

# Poll until completed
while true; do
  STATUS=$(curl -s https://api.snapshotarchive.com/v1/snapshots/$SNAPSHOT_ID \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Accept: application/json" | jq -r '.data.status')

  echo "Status: $STATUS"

  if [ "$STATUS" = "completed" ] || [ "$STATUS" = "failed" ]; then
    break
  fi

  sleep 5
done

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

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

// Poll until completed
do {
    sleep(5);
    $snapshot = Http::withToken('YOUR_API_KEY')
        ->get("https://api.snapshotarchive.com/v1/snapshots/{$snapshotId}")
        ->json('data');
} while (in_array($snapshot['status'], ['pending', 'processing']));

// Download screenshot
if ($snapshot['status'] === 'completed') {
    $screenshotUrl = $snapshot['files']['screenshot_url'];
}

import time
import requests

API_KEY = 'YOUR_API_KEY'
BASE = 'https://api.snapshotarchive.com/v1'
headers = {'Authorization': f'Bearer {API_KEY}', 'Accept': 'application/json'}

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

# Poll until completed
while True:
    time.sleep(5)
    snap = requests.get(f'{BASE}/snapshots/{snapshot_id}', headers=headers).json()['data']
    if snap['status'] in ('completed', 'failed'):
        break

# Download screenshot
if snap['status'] == 'completed':
    screenshot_url = snap['files']['screenshot_url']
    img = requests.get(screenshot_url)
    with open('screenshot.png', 'wb') as f:
        f.write(img.content)

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://api.snapshotarchive.com/v1';
const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Accept': 'application/json',
};

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

// Poll until completed
const sleep = ms => new Promise(r => setTimeout(r, ms));
let snapshot;
do {
  await sleep(5000);
  const res = await fetch(`${BASE}/snapshots/${snapshot_id}`, { headers });
  snapshot = (await res.json()).data;
} while (['pending', 'processing'].includes(snapshot.status));

// Download screenshot
if (snapshot.status === 'completed') {
  const img = await fetch(snapshot.files.screenshot_url);
  // save to file or process the image
}

# List diffs for monitor 42 (get monitor ID from GET /v1/monitors)
curl "https://api.snapshotarchive.com/v1/monitors/42/diffs?is_significant=true" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Get monitor ID first
monitors = requests.get(f'{BASE}/monitors', headers=headers, params={'url': 'example.com'}).json()
monitor_id = monitors['data'][0]['id']

# List significant diffs
diffs = requests.get(
    f'{BASE}/monitors/{monitor_id}/diffs',
    headers=headers,
    params={'is_significant': 'true', 'sort': 'change_percent', 'order': 'desc'}
).json()

for diff in diffs['data']:
    print(f"Diff #{diff['id']}: {diff['change_percent']}% change on {diff['created_at']}")

// Get monitor ID first
const monitors = await fetch(`${BASE}/monitors?url=example.com`, { headers }).then(r => r.json());
const monitorId = monitors.data[0].id;

// List significant diffs
const params = new URLSearchParams({ is_significant: 'true', sort: 'change_percent', order: 'desc' });
const { data: diffs } = await fetch(`${BASE}/monitors/${monitorId}/diffs?${params}`, { headers })
  .then(r => r.json());

diffs.forEach(d => {
  console.log(`Diff #${d.id}: ${d.change_percent}% change on ${d.created_at}`);
});

# Use the diff ID from the diffs list response
curl "https://api.snapshotarchive.com/v1/diffs/789" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

# Get diff details with the diff image URL
diff_id = 789  # from the diffs list response
diff = requests.get(f'{BASE}/diffs/{diff_id}', headers=headers).json()['data']

print(f"Change: {diff['change_percent']}%")
print(f"Diff image: {diff['diff_image_url']}")

// Get diff details with the diff image URL
const diffId = 789; // from the diffs list response
const { data: diff } = await fetch(`${BASE}/diffs/${diffId}`, { headers }).then(r => r.json());

console.log(`Change: ${diff.change_percent}%`);
console.log(`Diff image: ${diff.diff_image_url}`);

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

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

print(f"Plan: {account['plan']['name']}")
print(f"Monitors limit: {account['plan']['monitors_limit']}")
print(f"API access: {account['plan']['api_access']}")

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

console.log(`Plan: ${account.plan.name}`);
console.log(`Monitors limit: ${account.plan.monitors_limit}`);

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

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

monitors = usage['monitors']
print(f"Monitors: {monitors['used']}/{monitors['limit']} ({monitors['remaining']} remaining)")
print(f"Snapshots today: {usage['snapshots_today']}")

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

console.log(`Monitors: ${usage.monitors.used}/${usage.monitors.limit}`);
console.log(`Snapshots today: ${usage.snapshots_today}`);

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

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

for tag in tags:
    print(f"{tag['name']}: {tag['monitors_count']} monitors")

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

tags.forEach(tag => {
  console.log(`${tag.name}: ${tag.monitors_count} monitors`);
});

# Get the screenshot from September 5, 2026
# Use captured_before to get the latest snapshot on or before that date
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"

# The first item in "data" is the closest snapshot before that date
# Use the snapshot UUID to download the image:
curl -L "https://api.snapshotarchive.com/v1/snapshots/SNAPSHOT_UUID/screenshot" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o screenshot-sept5.png

import requests

API_KEY = 'YOUR_API_KEY'
BASE = 'https://api.snapshotarchive.com/v1'
headers = {'Authorization': f'Bearer {API_KEY}', 'Accept': 'application/json'}

# Step 1: Find the monitor by URL
monitors = requests.get(f'{BASE}/monitors', headers=headers, params={'url': 'example.com'}).json()
monitor_id = monitors['data'][0]['id']  # e.g. 42
print(f"Monitor ID: {monitor_id}")

# Step 2: Get the closest snapshot on or before September 5
response = requests.get(
    f'{BASE}/monitors/{monitor_id}/snapshots',
    headers=headers,
    params={
        'captured_before': '2026-09-05T23:59:59Z',
        'status': 'completed',
        'per_page': 1,
    }
)
snapshots = response.json()['data']

if snapshots:
    snapshot = snapshots[0]
    print(f"Found: {snapshot['captured_at']}")

    # Step 3: Download the image
    detail = requests.get(f"{BASE}/snapshots/{snapshot['id']}", headers=headers).json()['data']
    img = requests.get(detail['files']['screenshot_url'])
    with open('screenshot-sept5.png', 'wb') as f:
        f.write(img.content)
else:
    print("No snapshot found for that date")

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://api.snapshotarchive.com/v1';
const headers = { 'Authorization': `Bearer ${API_KEY}`, 'Accept': 'application/json' };

// Step 1: Find the monitor by URL
const monitors = await fetch(`${BASE}/monitors?url=example.com`, { headers }).then(r => r.json());
const monitorId = monitors.data[0].id; // e.g. 42
console.log(`Monitor ID: ${monitorId}`);

// Step 2: Get the closest snapshot on or before September 5
const params = new URLSearchParams({
  captured_before: '2026-09-05T23:59:59Z',
  status: 'completed',
  per_page: '1',
});
const snapshotsRes = await fetch(`${BASE}/monitors/${monitorId}/snapshots?${params}`, { headers });
const { data: snapshots } = await snapshotsRes.json();

if (snapshots.length > 0) {
  const snapshot = snapshots[0];
  console.log(`Found: ${snapshot.captured_at}`);

  // Step 3: Get download URLs
  const detail = await fetch(`${BASE}/snapshots/${snapshot.id}`, { headers }).then(r => r.json());
  console.log('Screenshot URL:', detail.data.files.screenshot_url);
} else {
  console.log('No snapshot found for that date');
}

# Get significant diffs from the past 7 days for monitor 42
curl "https://api.snapshotarchive.com/v1/monitors/42/diffs?created_after=2026-09-07&is_significant=true&sort=change_percent&order=desc" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/json"

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

from datetime import datetime, timedelta

# Check all monitors for significant changes this week
monitors = requests.get(f'{BASE}/monitors?status=active', headers=headers).json()['data']
week_ago = (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d')

for monitor in monitors:
    diffs = requests.get(
        f"{BASE}/monitors/{monitor['id']}/diffs",
        headers=headers,
        params={
            'created_after': week_ago,
            'is_significant': 'true',
            'sort': 'change_percent',
            'order': 'desc',
        }
    ).json()

    if diffs['meta']['total'] > 0:
        top_diff = diffs['data'][0]
        print(f"{monitor['url']}: {top_diff['change_percent']}% change on {top_diff['created_at']}")

// Check all monitors for significant changes this week
const weekAgo = new Date(Date.now() - 7 * 86400000).toISOString().split('T')[0];
const monitors = await fetch(`${BASE}/monitors?status=active`, { headers }).then(r => r.json());

for (const monitor of monitors.data) {
  const params = new URLSearchParams({
    created_after: weekAgo,
    is_significant: 'true',
    sort: 'change_percent',
    order: 'desc',
  });

  const diffs = await fetch(`${BASE}/monitors/${monitor.id}/diffs?${params}`, { headers })
    .then(r => r.json());

  if (diffs.meta.total > 0) {
    const top = diffs.data[0];
    console.log(`${monitor.url}: ${top.change_percent}% change on ${top.created_at}`);
  }
}

#!/bin/bash
API_KEY="YOUR_API_KEY"
MONITOR_ID=42
BASE="https://api.snapshotarchive.com/v1"
OUTPUT_DIR="./screenshots"
mkdir -p "$OUTPUT_DIR"

PAGE=1
while true; do
  RESPONSE=$(curl -s "$BASE/monitors/$MONITOR_ID/snapshots?captured_after=2026-09-01&captured_before=2026-09-30&status=completed&per_page=20&page=$PAGE" \
    -H "Authorization: Bearer $API_KEY" \
    -H "Accept: application/json")

  # Extract snapshot IDs
  IDS=$(echo "$RESPONSE" | jq -r '.data[].id')
  [ -z "$IDS" ] && break

  for ID in $IDS; do
    DATE=$(echo "$RESPONSE" | jq -r ".data[] | select(.id==\"$ID\") | .captured_at[:10]")
    curl -sL "$BASE/snapshots/$ID/screenshot" \
      -H "Authorization: Bearer $API_KEY" \
      -o "$OUTPUT_DIR/$DATE-$ID.png"
    echo "Downloaded: $DATE-$ID.png"
  done

  LAST_PAGE=$(echo "$RESPONSE" | jq '.meta.last_page')
  [ "$PAGE" -ge "$LAST_PAGE" ] && break
  PAGE=$((PAGE + 1))
done

echo "Done! Downloaded to $OUTPUT_DIR"

import os, requests

API_KEY = 'YOUR_API_KEY'
BASE = 'https://api.snapshotarchive.com/v1'
headers = {'Authorization': f'Bearer {API_KEY}', 'Accept': 'application/json'}

def download_all_snapshots(monitor_id, date_from, date_to, output_dir='./screenshots'):
    os.makedirs(output_dir, exist_ok=True)
    page = 1

    while True:
        response = requests.get(
            f'{BASE}/monitors/{monitor_id}/snapshots',
            headers=headers,
            params={
                'captured_after': date_from,
                'captured_before': date_to,
                'status': 'completed',
                'per_page': 20,
                'page': page,
            }
        ).json()

        for snap in response['data']:
            # Get signed URL
            detail = requests.get(f"{BASE}/snapshots/{snap['id']}", headers=headers).json()['data']
            url = detail['files']['screenshot_url']
            if url:
                date = snap['captured_at'][:10]
                filename = f"{date}-{snap['id'][:8]}.png"
                img = requests.get(url)
                with open(os.path.join(output_dir, filename), 'wb') as f:
                    f.write(img.content)
                print(f"Downloaded: {filename}")

        if page >= response['meta']['last_page']:
            break
        page += 1

# Download all September 2026 screenshots for monitor 42
download_all_snapshots(42, '2026-09-01', '2026-09-30')

import { writeFile, mkdir } from 'fs/promises';

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://api.snapshotarchive.com/v1';
const headers = { 'Authorization': `Bearer ${API_KEY}`, 'Accept': 'application/json' };

async function downloadAllSnapshots(monitorId, dateFrom, dateTo, outputDir = './screenshots') {
  await mkdir(outputDir, { recursive: true });
  let page = 1;

  while (true) {
    const params = new URLSearchParams({
      captured_after: dateFrom, captured_before: dateTo,
      status: 'completed', per_page: '20', page: String(page),
    });

    const res = await fetch(`${BASE}/monitors/${monitorId}/snapshots?${params}`, { headers });
    const { data, meta } = await res.json();

    for (const snap of data) {
      const detail = await fetch(`${BASE}/snapshots/${snap.id}`, { headers }).then(r => r.json());
      const url = detail.data.files.screenshot_url;
      if (url) {
        const img = await fetch(url).then(r => r.arrayBuffer());
        const date = snap.captured_at.slice(0, 10);
        const filename = `${date}-${snap.id.slice(0, 8)}.png`;
        await writeFile(`${outputDir}/${filename}`, Buffer.from(img));
        console.log(`Downloaded: ${filename}`);
      }
    }

    if (page >= meta.last_page) break;
    page++;
  }
}

await downloadAllSnapshots(42, '2026-09-01', '2026-09-30');