Integrations

BoltShot integrates seamlessly with popular automation platforms like Zapier, n8n, and Make (formerly Integromat). This guide shows you how to set up integrations for automated screenshot workflows.

Overview

All integrations use BoltShot's REST API with API key authentication. The API uses GET requests with query parameters, making it compatible with most automation platforms.

Prerequisites

BoltShot Account: Sign up at boltshot.dev
API Key: Create an API key in your dashboard
Automation Platform Account: Zapier, n8n, or Make account

Zapier Integration

Setting Up BoltShot in Zapier

Create a New Zap
- Go to Zapier and create a new Zap
- Choose your trigger (e.g., "New Email", "New Form Submission", etc.)
Add BoltShot Action
- Search for "Webhooks by Zapier" or "Code by Zapier"
- Select "GET" action for Webhooks, or use Code for more control

Configure the Request

Using Webhooks (GET):

URL: https://api.boltshot.dev/capture?url={{trigger_field_url}}&format=png&fullPage=true&apiKey=YOUR_API_KEY
Method: GET

Using Code (JavaScript):

const baseUrl = 'https://api.boltshot.dev/capture';
const apiKey = 'YOUR_API_KEY';
const targetUrl = encodeURIComponent(inputData.url); // From trigger

const url = `${baseUrl}?url=${targetUrl}&format=png&fullPage=true&apiKey=${apiKey}`;

const response = await fetch(url, {
  method: 'GET'
});

// For binary response, convert to base64
const arrayBuffer = await response.arrayBuffer();
const base64 = btoa(String.fromCharCode(...new Uint8Array(arrayBuffer)));
const dataUrl = `data:image/png;base64,${base64}`;

return {
  screenshotData: dataUrl,
  requestId: response.headers.get('X-Request-Id')
};

For JSON Response:

const baseUrl = 'https://api.boltshot.dev/capture';
const apiKey = 'YOUR_API_KEY';
const targetUrl = encodeURIComponent(inputData.url);

const url = `${baseUrl}?url=${targetUrl}&format=png&fullPage=true&returnFile=false&apiKey=${apiKey}`;

const response = await fetch(url);
const result = await response.json();

// Handle standardized response format
const data = result.data || result; // Support both formats for backward compatibility

return {
  screenshotUrl: data.url,
  imageData: data.imageData,
  requestId: data.requestId
};

Test and Activate
- Test the Zap with sample data
- Activate when ready

Example Zapier Workflows

1. Screenshot New Blog Posts

Trigger: New RSS Feed Item Action: BoltShot Screenshot

URL: https://api.boltshot.dev/capture?url={{RSS Feed URL}}&format=png&fullPage=true&apiKey=YOUR_API_KEY
Method: GET

Next Action: Save to Google Drive

Use screenshot data from response

2. Monitor Website Changes

Trigger: Schedule (every hour) Action: BoltShot Screenshot

URL: https://api.boltshot.dev/capture?url=https://your-website.com&format=png&fullPage=true&apiKey=YOUR_API_KEY
Method: GET

Next Action: Compare with previous screenshot

Use image comparison tool

Trigger: New Tweet/Post Action: BoltShot Screenshot

URL: Extract URL from tweet and construct: https://api.boltshot.dev/capture?url={{extracted_url}}&format=png&device=mobile&apiKey=YOUR_API_KEY
Method: GET

Next Action: Post to Instagram

Use screenshot as image

n8n Integration

Setting Up BoltShot in n8n

Create New Workflow
- Open n8n and create a new workflow
- Add your trigger node
Add HTTP Request Node
- Search for "HTTP Request" node
- Add it to your workflow

Configure HTTP Request Node

Settings:

Method: GET
URL: https://api.boltshot.dev/capture

Query Parameters:

url: ={{ $json.url }}
format: png
fullPage: true
apiKey: YOUR_API_KEY

For JSON Response:

url: ={{ $json.url }}
format: png
fullPage: true
returnFile: false
apiKey: YOUR_API_KEY

Process Response
- Add a "Set" node to extract data
- Map url and imageData from response (if using JSON)

Example n8n Workflows

1. Automated Screenshot on Webhook

Trigger: Webhook

Receives URL in payload

HTTP Request (BoltShot):

Method: GET
URL: https://api.boltshot.dev/capture
Query: url={{ $json.url }}&apiKey=YOUR_API_KEY

Next Node: Save to S3/Storage

Upload screenshot

2. Scheduled Website Monitoring

Trigger: Cron (daily at 9 AM) HTTP Request (BoltShot):

Method: GET
URL: https://api.boltshot.dev/capture
Query: url=https://your-website.com&format=png&fullPage=true&removeAds=true&apiKey=YOUR_API_KEY

Next Node: Compare with previous

Store in database
Alert on significant changes

3. Multi-URL Screenshot Batch

Trigger: Manual/Webhook Loop Over Items:

Process each URL

HTTP Request (BoltShot):

Screenshot each URL with GET request

Aggregate:

Collect all results

Make (Integromat) Integration

Setting Up BoltShot in Make

Create New Scenario
- Open Make and create a new scenario
- Add your trigger module
Add HTTP Module
- Search for "HTTP > Make a Request"
- Add it to your scenario

Configure HTTP Module

URL:

https://api.boltshot.dev/capture

Method:

GET

Query String:

url={{1.url}}
format=png
fullPage=true
apiKey=YOUR_API_KEY

For JSON Response:

url={{1.url}}
format=png
fullPage=true
returnFile=false
apiKey=YOUR_API_KEY

Map Response Data
- Use data mapper to extract fields
- Pass to next modules

Example Make Scenarios

1. Email to Screenshot

Trigger: Email (Gmail)

Watch for new emails with URLs

HTTP (BoltShot):

Method: GET
URL: https://api.boltshot.dev/capture
Query: url={{email_url}}&apiKey=YOUR_API_KEY

Next Module: Google Drive

Upload screenshot

2. Form Submission Screenshot

Trigger: Webhook (Form Submission)

Receives form data with URL

HTTP (BoltShot):

Method: GET
URL: https://api.boltshot.dev/capture
Query: url={{form_url}}&apiKey=YOUR_API_KEY

Next Module: Send Email

Include screenshot in email

Trigger: Twitter/Social Media

Monitor for mentions with URLs

HTTP (BoltShot):

Method: GET
URL: https://api.boltshot.dev/capture
Query: url={{mentioned_url}}&apiKey=YOUR_API_KEY

Next Module: Database

Store screenshots and metadata

Advanced Integration Patterns

Error Handling

All platforms should handle errors gracefully:

try {
  const url = `https://api.boltshot.dev/capture?url=${encodeURIComponent(targetUrl)}&apiKey=${apiKey}`;
  const response = await fetch(url);
  
  if (!response.ok) {
    const errorData = await response.json();
    
    // Handle standardized error format
    if (errorData.error && errorData.error.code) {
      const errorCode = errorData.error.code;
      const errorMessage = errorData.error.message;
      const errorDetails = errorData.error.details;
      
      // Handle specific error codes
      if (errorCode === 'RATE_LIMIT_EXCEEDED') {
        // Wait and retry
        await new Promise(resolve => setTimeout(resolve, 60000));
        return screenshotWithRetry(url, apiKey, maxRetries - 1);
      }
      
      throw new Error(`API Error [${errorCode}]: ${errorMessage}`);
    }
    
    // Fallback for legacy format
    throw new Error(`API Error: ${errorData.error || errorData.message || response.status}`);
  }
  
  return await response.arrayBuffer(); // or response.json() for JSON
} catch (error) {
  // Log error
  // Retry or notify
  throw error;
}

Retry Logic

Implement retry logic for transient failures:

async function screenshotWithRetry(url, apiKey, maxRetries = 3) {
  const fullUrl = `https://api.boltshot.dev/capture?url=${encodeURIComponent(url)}&apiKey=${apiKey}`;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(fullUrl);
      if (response.ok) return await response.arrayBuffer();
      
      if (response.status === 429) {
        // Rate limited - wait and retry
        const errorData = await response.json().catch(() => ({}));
        if (errorData.error && errorData.error.code === 'RATE_LIMIT_EXCEEDED') {
          await new Promise(resolve => setTimeout(resolve, 60000));
          continue;
        }
      }
      
      // Handle standardized error format
      const errorData = await response.json().catch(() => ({}));
      if (errorData.error && errorData.error.code) {
        throw new Error(`API Error [${errorData.error.code}]: ${errorData.error.message}`);
      }
      
      throw new Error(`HTTP ${response.status}`);
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
}

Batch Processing

For multiple URLs, process in batches:

async function batchScreenshots(urls, apiKey, batchSize = 5) {
  const results = [];
  for (let i = 0; i < urls.length; i += batchSize) {
    const batch = urls.slice(i, i + batchSize);
    const promises = batch.map(url => {
      const fullUrl = `https://api.boltshot.dev/capture?url=${encodeURIComponent(url)}&apiKey=${apiKey}`;
      return fetch(fullUrl).then(r => r.arrayBuffer());
    });
    const batchResults = await Promise.all(promises);
    results.push(...batchResults);
    // Rate limiting delay
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
  return results;
}

API Key Management

Best Practices

Separate Keys per Integration
- Create dedicated API keys for each platform
- Name them clearly (e.g., "Zapier Production", "n8n Dev")
Monitor Usage
- Check API key usage regularly
- Set up alerts for unusual activity
Rotate Keys
- Rotate keys periodically
- Update integrations when rotating

Rate Limiting

Be aware of rate limits:

Screenshots: 40 requests per minute per IP

Implement delays between requests in your automation workflows to stay within limits.

Testing Your Integration

Test Endpoint

Use a simple test to verify your setup:

GET https://api.boltshot.dev/capture?url=https://example.com&format=png&returnFile=false&apiKey=YOUR_API_KEY

Expected Response

{
  "success": true,
  "data": {
    "requestId": "uuid",
    "fileName": "screenshot.png",
    "processingTime": 2500,
    "fileSize": 1024000,
    "url": "https://storage.example.com/screenshots/screenshot.png",
    "imageData": "data:image/png;base64,..."
  }
}

Note: The response format uses data wrapper for consistency. When using returnFile=false, the response will be wrapped in the data field.

Troubleshooting

Common Issues

401 Unauthorized
- Error code: API_KEY_REQUIRED, INVALID_API_KEY, or API_KEY_EXPIRED
- Check API key is correct
- Verify key hasn't expired
- Ensure key has required permissions
429 Too Many Requests
- Error code: RATE_LIMIT_EXCEEDED
- Implement rate limiting in your workflow
- Add delays between requests
- Screenshot API limit: 40 requests per minute per IP
- Check X-RateLimit-Reset header for retry time
400 Bad Request
- Error code: VALIDATION_ERROR, MISSING_REQUIRED_FIELD, or INVALID_INPUT
- Verify URL is valid and accessible
- Check parameter types (booleans, numbers)
- Review error details in response (field-level validation errors)
402 Payment Required
- Error code: INSUFFICIENT_CREDITS
- Upgrade your subscription plan
- Purchase additional credits
500 Internal Server Error
- Error code: INTERNAL_ERROR or OPERATION_FAILED
- Retry the request
- Check BoltShot status page
- Contact support if persistent

Next Steps

Review Screenshot API for all available options
Check Authentication for API key management
See Errors for detailed error handling

Support

Need help with integrations?

Check platform-specific documentation
Review API Reference
Contact support at hello@boltshot.dev

Overview​

Prerequisites​

Zapier Integration​

Setting Up BoltShot in Zapier​

Example Zapier Workflows​

1. Screenshot New Blog Posts​

2. Monitor Website Changes​

3. Social Media Automation​

n8n Integration​

Setting Up BoltShot in n8n​

Example n8n Workflows​

1. Automated Screenshot on Webhook​

2. Scheduled Website Monitoring​

3. Multi-URL Screenshot Batch​

Make (Integromat) Integration​

Setting Up BoltShot in Make​

Example Make Scenarios​

1. Email to Screenshot​

2. Form Submission Screenshot​

3. Social Media Monitoring​

Advanced Integration Patterns​

Error Handling​

Retry Logic​

Batch Processing​

API Key Management​

Best Practices​

Rate Limiting​

Testing Your Integration​

Test Endpoint​

Expected Response​

Troubleshooting​

Common Issues​

Next Steps​

Support​

Overview

Prerequisites

Zapier Integration

Setting Up BoltShot in Zapier

Example Zapier Workflows

1. Screenshot New Blog Posts

2. Monitor Website Changes

3. Social Media Automation

n8n Integration

Setting Up BoltShot in n8n

Example n8n Workflows

1. Automated Screenshot on Webhook

2. Scheduled Website Monitoring

3. Multi-URL Screenshot Batch

Make (Integromat) Integration

Setting Up BoltShot in Make

Example Make Scenarios

1. Email to Screenshot

2. Form Submission Screenshot

3. Social Media Monitoring

Advanced Integration Patterns

Error Handling

Retry Logic

Batch Processing

API Key Management

Best Practices

Rate Limiting

Testing Your Integration

Test Endpoint

Expected Response

Troubleshooting

Common Issues

Next Steps

Support