Code Samples

const SNAPOPA_API_KEY = process.env.SNAPOPA_API_KEY;

async function captureScreenshot(url) {
  const response = await fetch('https://api.snapopa.com/capture', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${SNAPOPA_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ url }),
  });

  if (!response.ok) {
    throw new Error(`Capture failed: ${response.status}`);
  }

  return response.json();
}

// Usage
const result = await captureScreenshot('https://example.com');
console.log(result.data.fileUrl);

import os
import requests

SNAPOPA_API_KEY = os.environ['SNAPOPA_API_KEY']

def capture_screenshot(url):
    response = requests.post(
        'https://api.snapopa.com/capture',
        headers={
            'Authorization': f'Bearer {SNAPOPA_API_KEY}',
            'Content-Type': 'application/json',
        },
        json={'url': url}
    )
    response.raise_for_status()
    return response.json()

# Usage
result = capture_screenshot('https://example.com')
print(result['data']['fileUrl'])

package main

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

type CaptureRequest struct {
    URL string `json:"url"`
}

type CaptureResponse struct {
    Success bool `json:"success"`
    Data    struct {
        FileURL string `json:"fileUrl"`
    } `json:"data"`
}

func captureScreenshot(url string) (*CaptureResponse, error) {
    apiKey := os.Getenv("SNAPOPA_API_KEY")

    reqBody, _ := json.Marshal(CaptureRequest{URL: url})
    req, _ := http.NewRequest("POST", "https://api.snapopa.com/capture", bytes.NewBuffer(reqBody))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result CaptureResponse
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, nil
}

func main() {
    result, _ := captureScreenshot("https://example.com")
    fmt.Println(result.Data.FileURL)
}

<?php

$apiKey = getenv('SNAPOPA_API_KEY');

function captureScreenshot($url) {
    global $apiKey;

    $ch = curl_init('https://api.snapopa.com/capture');
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . $apiKey,
            'Content-Type: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode(['url' => $url]),
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Usage
$result = captureScreenshot('https://example.com');
echo $result['data']['fileUrl'];

def capture_with_options(
    url,
    format='png',
    width=1920,
    height=1080,
    full_page=False,
    quality=95,
    wait_until='domcontentloaded',
    cache=False,
    cache_ttl=86400,
):
    response = requests.post(
        'https://api.snapopa.com/capture',
        headers={
            'Authorization': f'Bearer {os.environ["SNAPOPA_API_KEY"]}',
            'Content-Type': 'application/json',
        },
        json={
            'url': url,
            'format': format,
            'viewport': {
                'width': width,
                'height': height,
            },
            'isFullPage': full_page,
            'quality': quality,
            'waitUntil': wait_until,
            'responseCache': {
                'enabled': cache,
                'ttl': cache_ttl,
            },
        }
    )
    return response.json()

# Usage
result = capture_with_options(
    url='https://example.com',
    format='webp',
    width=1280,
    height=720,
    full_page=True,
    cache=True,
)

def download_screenshot(url, output_path):
    response = requests.post(
        'https://api.snapopa.com/capture',
        headers={
            'Authorization': f'Bearer {os.environ["SNAPOPA_API_KEY"]}',
            'Content-Type': 'application/json',
        },
        json={
            'url': url,
            'responseType': 'file',
        }
    )

    with open(output_path, 'wb') as f:
        f.write(response.content)

# Usage
download_screenshot('https://example.com', './screenshot.png')

import time

def capture_with_retry(url, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                'https://api.snapopa.com/capture',
                headers={
                    'Authorization': f'Bearer {os.environ["SNAPOPA_API_KEY"]}',
                    'Content-Type': 'application/json',
                },
                json={'url': url}
            )

            if response.status_code == 429:
                reset_time = int(response.headers.get('X-RateLimit-Reset', 0))
                wait_time = max(reset_time - time.time(), 1)
                time.sleep(wait_time)
                continue

            response.raise_for_status()
            return response.json()

        except requests.RequestException:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)