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

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

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

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

{
  "data": {
    "message": "Snapshot queued successfully.",
    "snapshot_id": "9c8b7a6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d"
  }
}

{
  "data": {
    "id": 1,
    "name": "My Project",
    "created_at": "2025-01-15T10:30:00.000000Z"
  }
}

{
  "data": [ ... ],
  "meta": {
    "current_page": 1,
    "per_page": 20,
    "total": 42,
    "last_page": 3
  }
}

{
  "error": {
    "code": "invalid_api_key",
    "message": "The provided API key is invalid or has been revoked.",
    "status": 401
  }
}

Authorization: Bearer YOUR_API_KEY

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

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

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

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

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

import requests

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

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

const response = await fetch('https://snapshotarchive.com/api/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: 60 })
});

if (!response.ok) {
  const body = await response.json();

  if (body.error) {
    // API error (401, 403, 429, etc.)
    console.error(`API error [${body.error.code}]: ${body.error.message}`);
  } else if (body.errors) {
    // Validation error (422)
    Object.entries(body.errors).forEach(([field, messages]) => {
      console.error(`${field}: ${messages.join(', ')}`);
    });
  }
  return;
}

const { data } = await response.json();
console.log('Created monitor:', data.id);

$response = Http::withToken('YOUR_API_KEY')
    ->acceptJson()
    ->post('https://snapshotarchive.com/api/v1/monitors', [
        'url' => 'https://example.com',
        'frequency_minutes' => 60,
    ]);

if ($response->failed()) {
    if ($response->json('error')) {
        // API error (401, 403, 429, etc.)
        $code = $response->json('error.code');
        $message = $response->json('error.message');
        throw new \Exception("API error [{$code}]: {$message}");
    }

    if ($response->status() === 422) {
        // Validation errors
        $errors = $response->json('errors');
        // Handle field-level errors...
    }
}

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

async function getAllMonitors(apiKey) {
  let page = 1;
  let allMonitors = [];

  while (true) {
    const response = await fetch(
      `https://snapshotarchive.com/api/v1/monitors?page=${page}&per_page=100`,
      { headers: { 'Authorization': `Bearer ${apiKey}` } }
    );
    const { data, meta } = await response.json();
    allMonitors.push(...data);

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

  return allMonitors;
}

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 58

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Too many requests. Please retry after 42 seconds.",
    "status": 429
  }
}

{
  "error": {
    "code": "invalid_api_key",
    "message": "The provided API key is invalid or has been revoked.",
    "status": 401
  }
}

{
  "message": "The url field is required. (and 1 more error)",
  "errors": {
    "url": ["The url field is required."],
    "frequency_minutes": ["The frequency minutes field must be at least 5."]
  }
}

const API_KEY = 'YOUR_API_KEY';
const BASE    = 'https://snapshotarchive.com/api/v1';

const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type':  'application/json',
  'Accept':        'application/json',
};

// 1. Create a monitor
const monitor = await fetch(`${BASE}/monitors`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    url: 'https://example.com',
    frequency_minutes: 1440,
    viewport_width: 1920,
    viewport_height: 1080,
    device_type: 'desktop',
    full_page: true,
  }),
}).then(r => r.json());

const monitorId = monitor.data.id;
console.log('Monitor created:', monitorId);

// 2. Trigger a snapshot
const trigger = await fetch(`${BASE}/monitors/${monitorId}/trigger`, {
  method: 'POST',
  headers,
}).then(r => r.json());

const snapshotId = trigger.data.snapshot_id;
console.log('Snapshot queued:', snapshotId);

// 3. Poll until completed
let snapshot;
do {
  await new Promise(r => setTimeout(r, 5000));
  snapshot = await fetch(`${BASE}/snapshots/${snapshotId}`, { headers })
    .then(r => r.json());
} while (snapshot.data.status !== 'completed');

console.log('Screenshot URL:', snapshot.data.files.screenshot_url);

use Illuminate\Support\Facades\Http;

$api = Http::withToken('YOUR_API_KEY')
    ->acceptJson()
    ->baseUrl('https://snapshotarchive.com/api/v1');

// 1. Create a monitor
$monitor = $api->post('/monitors', [
    'url'               => 'https://example.com',
    'frequency_minutes' => 1440,
    'viewport_width'    => 1920,
    'viewport_height'   => 1080,
    'device_type'       => 'desktop',
    'full_page'         => true,
])->json('data');

// 2. Trigger a snapshot
$trigger = $api->post("/monitors/{$monitor['id']}/trigger")->json('data');
$snapshotId = $trigger['snapshot_id'];

// 3. Poll until completed
do {
    sleep(5);
    $snapshot = $api->get("/snapshots/{$snapshotId}")->json('data');
} while ($snapshot['status'] !== 'completed');

echo $snapshot['files']['screenshot_url'];

$apiKey  = 'YOUR_API_KEY';
$baseUrl = 'https://snapshotarchive.com/api/v1';

function apiRequest(string $method, string $url, ?array $data = null): array {
    global $apiKey;
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_HTTPHEADER     => [
            "Authorization: Bearer {$apiKey}",
            'Content-Type: application/json',
            'Accept: application/json',
        ],
    ]);
    if ($data) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    }
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

// 1. Create a monitor
$monitor = apiRequest('POST', "{$baseUrl}/monitors", [
    'url'               => 'https://example.com',
    'frequency_minutes' => 1440,
    'device_type'       => 'desktop',
]);

// 2. Trigger a snapshot
$trigger = apiRequest('POST', "{$baseUrl}/monitors/{$monitor['data']['id']}/trigger");
$snapshotId = $trigger['data']['snapshot_id'];

// 3. Poll until completed
do {
    sleep(5);
    $snapshot = apiRequest('GET', "{$baseUrl}/snapshots/{$snapshotId}");
} while ($snapshot['data']['status'] !== 'completed');

echo $snapshot['data']['files']['screenshot_url'];

import time
import requests

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

# 1. Create a monitor
monitor = requests.post(f'{BASE_URL}/monitors', headers=headers, json={
    'url': 'https://example.com',
    'frequency_minutes': 1440,
    'viewport_width': 1920,
    'viewport_height': 1080,
    'device_type': 'desktop',
    'full_page': True,
}).json()['data']

# 2. Trigger a snapshot
trigger = requests.post(
    f"{BASE_URL}/monitors/{monitor['id']}/trigger", headers=headers
).json()['data']

snapshot_id = trigger['snapshot_id']

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

print(snapshot['files']['screenshot_url'])

require 'net/http'
require 'json'
require 'uri'

API_KEY  = 'YOUR_API_KEY'
BASE_URL = 'https://snapshotarchive.com/api/v1'

def api_request(method, path, body = nil)
  uri = URI("#{BASE_URL}#{path}")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = uri.scheme == 'https'

  request = case method
            when :get    then Net::HTTP::Get.new(uri)
            when :post   then Net::HTTP::Post.new(uri)
            when :put    then Net::HTTP::Put.new(uri)
            when :delete then Net::HTTP::Delete.new(uri)
            end

  request['Authorization'] = "Bearer #{API_KEY}"
  request['Accept']        = 'application/json'
  request['Content-Type']  = 'application/json'
  request.body = body.to_json if body

  JSON.parse(http.request(request).body)
end

# 1. Create a monitor
monitor = api_request(:post, '/monitors', {
  url: 'https://example.com',
  frequency_minutes: 1440,
  device_type: 'desktop'
})

# 2. Trigger a snapshot
trigger = api_request(:post, "/monitors/#{monitor['data']['id']}/trigger")
snapshot_id = trigger['data']['snapshot_id']

# 3. Poll until completed
loop do
  sleep 5
  snapshot = api_request(:get, "/snapshots/#{snapshot_id}")
  break if snapshot['data']['status'] == 'completed'
end

puts snapshot['data']['files']['screenshot_url']

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

const (
    apiKey  = "YOUR_API_KEY"
    baseURL = "https://snapshotarchive.com/api/v1"
)

func apiRequest(method, path string, body any) map[string]any {
    var reqBody *bytes.Reader
    if body != nil {
        b, _ := json.Marshal(body)
        reqBody = bytes.NewReader(b)
    } else {
        reqBody = bytes.NewReader(nil)
    }

    req, _ := http.NewRequest(method, baseURL+path, reqBody)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result
}

func main() {
    // 1. Create a monitor
    monitor := apiRequest("POST", "/monitors", map[string]any{
        "url":               "https://example.com",
        "frequency_minutes": 1440,
        "device_type":       "desktop",
    })
    monitorID := monitor["data"].(map[string]any)["id"]

    // 2. Trigger a snapshot
    trigger := apiRequest("POST", fmt.Sprintf("/monitors/%v/trigger", monitorID), nil)
    snapshotID := trigger["data"].(map[string]any)["snapshot_id"]

    // 3. Poll until completed
    for {
        time.Sleep(5 * time.Second)
        snap := apiRequest("GET", fmt.Sprintf("/snapshots/%v", snapshotID), nil)
        data := snap["data"].(map[string]any)
        if data["status"] == "completed" {
            files := data["files"].(map[string]any)
            fmt.Println(files["screenshot_url"])
            break
        }
    }
}