API Documentation - ScrapingBot Web Scraping API

Introduction

ScrapingBot provides a powerful web scraping API that handles both static and dynamic websites with ease. Our API supports JavaScript rendering, stealth proxies, AI-powered data extraction, and much more.

API Endpoint

https://scrapingbot.io/api/v1/scrape

Authentication

All API requests require an API key passed in the x-api-key header.

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com" \
  -H "x-api-key: YOUR_API_KEY"

import requests

headers = {"x-api-key": "YOUR_API_KEY"}
response = requests.get("https://scrapingbot.io/api/v1/scrape?url=https://example.com", headers=headers)
print(response.json())

const axios = require('axios');

const response = await axios.get('https://scrapingbot.io/api/v1/scrape?url=https://example.com', {
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});
console.log(response.data);

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
print_r(json_decode($response, true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Quick Start

Get started with a simple scraping request in seconds. Choose your preferred language below.

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true" \
  -H "x-api-key: YOUR_API_KEY"

import requests

url = "https://scrapingbot.io/api/v1/scrape"
headers = {"x-api-key": "YOUR_API_KEY"}
params = {
    "url": "https://example.com",
    "render_js": "true"
}

response = requests.get(url, headers=headers, params=params)
data = response.json()

if data["success"]:
    print(data["html"])

const axios = require('axios');

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: {
    url: 'https://example.com',
    render_js: 'true'
  },
  headers: {
    'x-api-key': 'YOUR_API_KEY'
  }
});

if (response.data.success) {
  console.log(response.data.html);
}

<?php
$url = 'https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'x-api-key: YOUR_API_KEY'
]);

$response = curl_exec($ch);
$data = json_decode($response, true);

if ($data['success']) {
    echo $data['html'];
}
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

data = JSON.parse(response.body)
puts data['html'] if data['success']

package main

import (
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true"
    
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Response

{
  "success": true,
  "url": "https://example.com",
  "html": "<!DOCTYPE html>...",
  "statusCode": 200,
  "creditsUsed": 5,
  "credits": 245000,
  "duration": "2.34",
  "requestHeaders": { ... },
  "responseHeaders": { ... }
}

URL *

Required

The target URL to scrape. Must be a valid HTTP or HTTPS URL.

Parameter	url
Type	String (URL-encoded)
Required	Yes

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape', 
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://example.com"}
)
print(response.json())

const axios = require('axios');

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://example.com' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});
console.log(response.data);

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Render JavaScript

5 credits

Use a headless browser to render JavaScript and capture dynamic content. Perfect for modern web applications built with React, Vue, or Angular.

Parameter	render_js
Type	Boolean
Default	true
Cost	5 credits (vs 1 credit for HTTP)

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://example.com", "render_js": "true"}
)
print(response.json())

const axios = require('axios');

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://example.com', render_js: 'true' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});
console.log(response.data);

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com&render_js=true", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Stealth Proxy

75 credits

Use residential proxies with advanced stealth techniques to bypass bot detection on difficult websites. Recommended for sites with aggressive anti-scraping measures.

Parameter	stealth_proxy
Type	Boolean
Default	false
Cost	75 credits

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://difficult-site.com&stealth_proxy=true" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://difficult-site.com", "stealth_proxy": "true"}
)
print(response.json())

const axios = require('axios');

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://difficult-site.com', stealth_proxy: 'true' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});
console.log(response.data);

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://difficult-site.com&stealth_proxy=true');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://difficult-site.com&stealth_proxy=true')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://difficult-site.com&stealth_proxy=true", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Screenshot

Capture a screenshot of the page. Requires render_js=true.

Parameter	screenshot
Type	String
Values	visible_page \| full_page
Default	None (no screenshot)

Example: Full Page Screenshot

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&screenshot=full_page" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://example.com", "screenshot": "full_page"}
)
data = response.json()
print(data['screenshot'])  # base64-encoded PNG

const axios = require('axios');

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://example.com', screenshot: 'full_page' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

console.log(response.data.screenshot);  // base64-encoded PNG

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&screenshot=full_page');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$data = json_decode(curl_exec($ch), true);
echo $data['screenshot'];  // base64-encoded PNG
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&screenshot=full_page')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)
puts data['screenshot']  # base64-encoded PNG

package main

import ("encoding/json"; "fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com&screenshot=full_page", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    var data map[string]interface{}
    json.Unmarshal(body, &data)
    fmt.Println(data["screenshot"])  // base64-encoded PNG
}

Response: The screenshot is returned as a base64-encoded PNG in the screenshot field. You can save it to a file or display it directly.

JS Scenario (Browser Automation)

Automate complex browser interactions before scraping. Define a sequence of actions like clicking, scrolling, filling forms, and more. Browser-only - requires render_js=true.

Parameter	js_scenario
Type	JSON Array
Required	No

Supported Actions

evaluate

Execute custom JavaScript code in the browser

{"evaluate": "document.title"}

click

Click an element by CSS selector

{"click": "#submit-button"}

wait

Wait for a fixed duration (milliseconds)

{"wait": 2000}

wait_for

Wait for an element to appear

{"wait_for": "#dynamic-content"}

wait_for_and_click

Wait for an element then click it

{"wait_for_and_click": "#load-more"}

scroll_x / scroll_y

Scroll horizontally or vertically (pixels)

{"scroll_y": 1000}

fill

Fill an input field with a value

{"fill": ["#email", "[email protected]"]}

infinite_scroll

Automatically scroll to load dynamic content

{"infinite_scroll": {"max_count": 5, "delay": 1500, "end_click": {"selector": "#load-more"}}}

Example: Login and Scrape

cURL

Python

Node.js

curl -X POST "https://scrapingbot.io/api/v1/scrape" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/login",
    "render_js": true,
    "js_scenario": [
      {"fill": ["#username", "myuser"]},
      {"fill": ["#password", "mypass"]},
      {"click": "#login-button"},
      {"wait_for": ".dashboard"},
      {"scroll_y": 500}
    ]
  }'

import requests
import json

scenario = [
    {"fill": ["#username", "myuser"]},
    {"fill": ["#password", "mypass"]},
    {"click": "#login-button"},
    {"wait_for": ".dashboard"},
    {"scroll_y": 500}
]

response = requests.post('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "url": "https://example.com/login",
        "render_js": True,
        "js_scenario": scenario
    }
)

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

const axios = require('axios');

const scenario = [
  {fill: ["#username", "myuser"]},
  {fill: ["#password", "mypass"]},
  {click: "#login-button"},
  {wait_for: ".dashboard"},
  {scroll_y: 500}
];

const response = await axios.post('https://scrapingbot.io/api/v1/scrape', {
  url: 'https://example.com/login',
  render_js: true,
  js_scenario: scenario
}, {
  headers: {'x-api-key': 'YOUR_API_KEY'}
});

console.log(response.data.html);

Example: Infinite Scroll

cURL

Python

curl -X POST "https://scrapingbot.io/api/v1/scrape" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/feed",
    "render_js": true,
    "js_scenario": [
      {"wait_for": ".post"},
      {"infinite_scroll": {
        "max_count": 10,
        "delay": 2000
      }}
    ]
  }'

import requests

response = requests.post('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "url": "https://example.com/feed",
        "render_js": True,
        "js_scenario": [
            {"wait_for": ".post"},
            {"infinite_scroll": {
                "max_count": 10,
                "delay": 2000
            }}
        ]
    }
)

print(response.json()['html'])

💡 Tips

Actions execute sequentially in order
Failed steps don't stop execution - check the response for errors
Use wait_for before interacting with dynamic elements
Combine with screenshot to debug scenarios visually
Infinite scroll with max_count: 0 runs until no more content loads

Cookies

Pass custom cookies to your requests. Useful for accessing authenticated pages or maintaining sessions.

Parameter	cookies
Type	String
Format	name1=value1; name2=value2
Example	session=abc123; auth_token=xyz789

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&cookies=session%3Dabc123%3B%20auth_token%3Dxyz789" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={
        "url": "https://example.com",
        "cookies": "session=abc123; auth_token=xyz789"
    }
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { 
    url: 'https://example.com',
    cookies: 'session=abc123; auth_token=xyz789'
  },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&cookies=session%3Dabc123%3B%20auth_token%3Dxyz789');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&cookies=session%3Dabc123%3B%20auth_token%3Dxyz789')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(request) }
puts JSON.parse(response.body)

import ("fmt"; "io"; "net/http")

func main() {
    url := "https://scrapingbot.io/api/v1/scrape?url=https://example.com&cookies=session%3Dabc123%3B%20auth_token%3Dxyz789"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

💡 Use Cases

Access authenticated pages without logging in
Maintain session state across requests
Bypass cookie consent walls
Scrape user-specific content

AI Extraction

+5 credits

Use AI to extract specific data from the scraped HTML. Simply describe what you want to extract in natural language.

Parameter	ai_query
Type	String
Cost	+5 credits (in addition to scraping cost)

Example: Extract Product Information

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://store.com/product&ai_query=product%20price%20and%20title" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape', {
    headers={'x-api-key': 'YOUR_API_KEY'},
    params={
        'url': 'https://store.com/product',
        'ai_query': 'product price and title'
    }
})

data = response.json()
if data['success']:
    print('Extracted:', data['ai_result'])

const axios = require('axios');

const { data } = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: {
    url: 'https://store.com/product',
    ai_query: 'product price and title'
  },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

if (data.success) {
  console.log('Extracted:', data.ai_result);
}

<?php
$url = 'https://scrapingbot.io/api/v1/scrape?url=https://store.com/product&ai_query=product%20price%20and%20title';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);

if ($data['success']) {
    print_r($data['ai_result']);
}
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://store.com/product&ai_query=product%20price%20and%20title')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

if data['success']
  puts 'Extracted:', data['ai_result']
end

package main

import ("encoding/json"; "fmt"; "io"; "net/http")

func main() {
    url := "https://scrapingbot.io/api/v1/scrape?url=https://store.com/product&ai_query=product%20price%20and%20title"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    var data map[string]interface{}
    json.Unmarshal(body, &data)
    
    if data["success"] == true {
        fmt.Println("Extracted:", data["ai_result"])
    }
}

Response: Extracted data is returned in the ai_result field as structured JSON.

{
  "success": true,
  "ai_result": {
    "product_price": "$29.99",
    "title": "Premium Widget"
  },
  "ai_query": "product price and title"
}

Wait Options

Control how the browser waits for content to load. Only applies when render_js=true.

Wait for Selector

Wait for a specific CSS selector to appear before capturing the page.

Parameter	wait_for
Example	.product, #content, h1

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_for=%23content" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://example.com", "wait_for": "#content"}
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://example.com', wait_for: '#content' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_for=%23content');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_for=%23content')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_for=%23content", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Additional Wait Time

Wait for additional milliseconds after page load. Useful for animations or delayed content.

Parameter	wait
Type	Integer (milliseconds)
Example	2000 (wait 2 seconds)

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait=3000" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://example.com", "wait": "3000"}
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://example.com', wait: '3000' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait=3000');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait=3000')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait=3000", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Wait for Browser Event

Choose what browser event to wait for before capturing content.

Parameter	wait_browser
Values	`load` - Full page load `domcontentloaded` - DOM ready (default) `networkidle0` - No network connections `networkidle2` - Max 2 connections

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_browser=networkidle0" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://example.com", "wait_browser": "networkidle0"}
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://example.com', wait_browser: 'networkidle0' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_browser=networkidle0');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_browser=networkidle0')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://example.com&wait_browser=networkidle0", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Block Resources

Improve performance by blocking unnecessary resources. Only applies when render_js=true.

Parameters	block_ads, block_resources
Effect	`block_ads` - Blocks known ad networks (default: false) `block_resources` - Blocks images, CSS, fonts (default: false)
Default	block_resources: false block_ads: false
Benefit	Faster scraping, lower bandwidth usage

Example: Disable Blocking to Load All Assets

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&block_resources=false&block_ads=false" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={
        "url": "https://example.com",
        "block_resources": "false",
        "block_ads": "false"
    }
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { 
    url: 'https://example.com', 
    block_resources: 'false',
    block_ads: 'false'
  },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&block_resources=false&block_ads=false');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&block_resources=false&block_ads=false')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    url := "https://scrapingbot.io/api/v1/scrape?url=https://example.com&block_resources=false&block_ads=false"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Viewport Size

Set custom browser viewport dimensions. Only applies when render_js=true.

Parameters	window_width, window_height
Type	Integer (pixels)
Default	1920 × 1080

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://example.com&window_width=1280&window_height=720" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={
        "url": "https://example.com",
        "window_width": "1280",
        "window_height": "720"
    }
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { 
    url: 'https://example.com', 
    window_width: '1280',
    window_height: '720'
  },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://example.com&window_width=1280&window_height=720');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://example.com&window_width=1280&window_height=720')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    url := "https://scrapingbot.io/api/v1/scrape?url=https://example.com&window_width=1280&window_height=720"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Timeout

Maximum time to wait for the page to load (in milliseconds).

Parameter	timeout
Type	Integer (milliseconds)
Default	45000 (45 seconds)
Maximum	45000 (45 seconds)

cURL

Python

Node.js

PHP

Ruby

curl "https://scrapingbot.io/api/v1/scrape?url=https://slow-site.com&timeout=15000" \
  -H "x-api-key: YOUR_API_KEY"

import requests

response = requests.get('https://scrapingbot.io/api/v1/scrape',
    headers={"x-api-key": "YOUR_API_KEY"},
    params={"url": "https://slow-site.com", "timeout": "15000"}
)
print(response.json())

const response = await axios.get('https://scrapingbot.io/api/v1/scrape', {
  params: { url: 'https://slow-site.com', timeout: '15000' },
  headers: { 'x-api-key': 'YOUR_API_KEY' }
});

<?php
$ch = curl_init('https://scrapingbot.io/api/v1/scrape?url=https://slow-site.com&timeout=15000');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['x-api-key: YOUR_API_KEY']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
print_r(json_decode(curl_exec($ch), true));
?>

require 'net/http'
require 'json'

uri = URI('https://scrapingbot.io/api/v1/scrape?url=https://slow-site.com&timeout=15000')
request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
puts JSON.parse(response.body)

package main

import ("fmt"; "io"; "net/http")

func main() {
    req, _ := http.NewRequest("GET", "https://scrapingbot.io/api/v1/scrape?url=https://slow-site.com&timeout=15000", nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Response Format

All successful responses return JSON with the following structure:

{
  "success": true,
  "url": "https://example.com",
  "html": "<!DOCTYPE html><html>...",
  "statusCode": 200,
  "creditsUsed": 5,
  "duration": "2.34",
  "requestHeaders": { ... },
  "responseHeaders": { ... },
  "screenshot": "base64-encoded-png...",
  "ai_result": { ... },
  "ai_query": "product price"
}

Error Handling

Errors return JSON with success: false and an error message.

{
  "success": false,
  "error": "Insufficient credits. This request requires 5 credits.",
  "timestamp": "2025-01-01T12:00:00.000Z"
}

Common HTTP Status Codes

Code	Meaning
200	Success
400	Bad Request (missing URL)
402	Payment Required (insufficient credits)
429	Rate Limit Exceeded (concurrency)
500	Internal Server Error

Pricing

Credit costs vary based on the features you use:

Feature	Credits
HTTP Scraping (static pages)	1 credit
Browser Scraping (JavaScript rendering)	5 credits
Stealth Proxy	75 credits
AI Extraction	+5 credits

Note: Costs are cumulative. For example, browser scraping with stealth proxy costs 75 credits (stealth proxy includes browser rendering).

Concurrency Limits

Rate limits are based on your subscription plan:

Plan	Monthly Credits	Concurrent Requests
Free	100	1
Starter	250,000	10
Startup	1,000,000	50
Pro	3,000,000	100
Business	8,000,000	200
Business+	14,000,000	200

Get Started with Free Plan

Best Practices

✓ Use Browser Mode for Dynamic Sites

If the website uses JavaScript to load content, enable render_js=true to get the fully rendered page.

✓ Use Wait Options for Slow Sites

Combine wait_for and wait_browser to ensure content is fully loaded before scraping.

✓ Block Resources by Default

Images, CSS, and fonts are not blocked by default. Set block_resources=true when you want faster scraping and lower bandwidth usage. Ads are not blocked by default.

✓ Use AI Extraction for Structured Data

Instead of parsing HTML yourself, use AI extraction to get clean, structured data with natural language queries.

ChatGPT API - Introduction

Access ChatGPT (GPT-5) for AI-powered text generation, content creation, and natural language processing. Fast, reliable, and affordable at just 10 credits per request.

Endpoint: POST https://scrapingbot.io/api/v1/chatgpt

Cost: 10 credits per request • Model: GPT-5

Key Features

Latest GPT-5 model for highest quality responses
Fast response times (average <2 seconds)
No rate limits - send as many requests as you have credits
Supports any language and use case
Simple JSON request/response format

Authentication

All ChatGPT API requests require authentication using your API key. Include your API key in the request headers or as a query parameter.

curl -X POST "https://scrapingbot.io/api/v1/chatgpt" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Your prompt here"}'

Get your API key from your dashboard.

Quick Start

Basic Request

curl -X POST "https://scrapingbot.io/api/v1/chatgpt" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Explain quantum computing in simple terms"
  }'

Response

{
  "success": true,
  "response": "Quantum computing uses quantum mechanics...",
  "duration": "1.45"
}

Content Generation

Use ChatGPT to generate blog posts, product descriptions, social media content, email copy, and more.

Example: Product Description

{
  "prompt": "Write a compelling product description for eco-friendly bamboo toothbrushes"
}

Example: Blog Outline

{
  "prompt": "Create a blog post outline about the future of renewable energy"
}

Example: Social Media Captions

{
  "prompt": "Generate 5 Instagram captions for a coffee shop posting a latte art photo"
}

Text Analysis & Summarization

Summarize articles, extract key points, analyze sentiment, and process large amounts of text.

Example: Article Summarization

{
  "prompt": "Summarize this article in 3 bullet points: [article text]"
}

Example: Key Points Extraction

{
  "prompt": "Extract the main takeaways from this customer review: [review text]"
}

Code Generation

Generate code snippets, fix bugs, explain code, and get programming assistance.

Example: Generate Python Function

{
  "prompt": "Write a Python function to validate email addresses using regex"
}

Example: Debug Code

{
  "prompt": "Explain what's wrong with this code and how to fix it: [code snippet]"
}

Translation

Translate text between languages with context awareness and natural phrasing.

Example: Translate to Spanish

{
  "prompt": "Translate this to Spanish: 'Welcome to our website. We offer premium products at affordable prices.'"
}

Example: Multi-language Translation

{
  "prompt": "Translate 'Thank you for your purchase' into French, German, and Japanese"
}

Response Format

All successful ChatGPT API requests return a JSON object with the following structure:

{
  "success": true,           // Request succeeded
  "response": "...",         // ChatGPT's text response
  "duration": "1.23"         // Response time in seconds
}

Field Descriptions

Field	Type	Description
success	boolean	Whether the request was successful
response	string	ChatGPT's generated text response
duration	string	Response time in seconds

Pricing

10 Credits

per ChatGPT request

Free tier includes 1,000 credits = 100 ChatGPT requests per month. View all plans →

Google Search API - Introduction

Search Google programmatically and get organic results, rankings, snippets, related searches, and "People Also Ask" questions. No CAPTCHA solving required, no IP blocks.

Endpoint: POST https://scrapingbot.io/api/v1/google

Cost: 10 credits per request

Key Features

Get organic search results with titles, links, and snippets
Extract rankings and positions
Access "People Also Ask" questions and answers
Get related searches for SEO research
Support for country and language targeting
Pagination support for deep results

Authentication

Authentication works the same as other ScrapingBot APIs - include your API key in the x-api-key header.

-H "x-api-key: YOUR_API_KEY"

Quick Start

Basic Search Request

curl -X POST "https://scrapingbot.io/api/v1/google" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/search",
    "params": {
      "q": "best web scraping tools 2025"
    }
  }'

Response

{
  "success": true,
  "searchParameters": {...},
  "organic": [...],
  "relatedSearches": [...],
  "peopleAlsoAsk": [...]
}

Search Query (q)

The q parameter is required and specifies your search query.

"params": {
  "q": "best restaurants in New York"
}

Tips: Use natural language queries just like you would in Google. Special operators like quotes, site:, and intitle: are supported.

Country & Language

Target specific countries and languages for localized search results.

Country Code (gl)

"params": {
  "q": "best pizza",
  "gl": "us"  // United States
}

Language (hl)

"params": {
  "q": "mejores restaurantes",
  "hl": "es"  // Spanish
}

Common country codes: us, uk, ca, au, de, fr

Pagination

Control the number of results and pagination to get deep search results.

Number of Results (num)

"params": {
  "q": "web development",
  "num": 20  // Get 20 results (default: 10)
}

Page Number (page)

"params": {
  "q": "web development",
  "page": 2  // Get page 2 of results
}

Response Format

{
  "success": true,
  "searchParameters": {
    "q": "best web scraping tools",
    "gl": "us",
    "hl": "en"
  },
  "organic": [
    {
      "position": 1,
      "title": "Top 10 Web Scraping Tools for 2025",
      "link": "https://example.com/scraping-tools",
      "snippet": "Discover the best web scraping tools...",
      "displayedLink": "example.com › scraping-tools"
    }
  ],
  "relatedSearches": [
    "python web scraping",
    "beautiful soup tutorial"
  ],
  "peopleAlsoAsk": [
    {
      "question": "What is web scraping?",
      "answer": "Web scraping is the process of..."
    }
  ],
  "duration": "0.85"
}

Pricing

10 Credits

per search request

Free tier includes 1,000 credits = 100 Google searches per month. View all plans →

TikTok API - Introduction

Extract TikTok videos, user profiles, posts, and comments programmatically. No authentication or login required. Get video metadata, download links, user stats, and more.

Endpoint: POST https://scrapingbot.io/api/v1/tiktok

Cost: 1 credit per request

Available Endpoints

Video information & download links

/user/info

User profile & statistics

/user/posts

User's recent videos

/comment/list

Video comments

Authentication

Include your API key in the x-api-key header with every request.

-H "x-api-key: YOUR_API_KEY"

Quick Start

Get Video Information

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/",
    "params": {
      "url": "https://www.tiktok.com/@user/video/1234567890"
    }
  }'

Video Information

Get complete video metadata including title, description, statistics, author info, and download links.

Endpoint

"endpoint": "/"

Parameters

Parameter	Required	Description
url	Yes	Full TikTok video URL
hd	No	Set to "1" for HD download link

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/",
    "params": {
      "url": "https://www.tiktok.com/@nike/video/7123456789012345678",
      "hd": "1"
    }
  }'

Response Data

Returns: video title, description, play count, like count, comment count, share count, author info, download links (SD and HD), music info, and more.

User Profile

Get detailed TikTok user profile information including follower count, following count, total likes, bio, and avatar.

Endpoint

"endpoint": "/user/info"

Parameters

unique_id

Yes

TikTok username (without @)

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/user/info",
    "params": {
      "unique_id": "nike"
    }
  }'

User Videos

Retrieve a user's recent TikTok videos with metadata, statistics, and download links.

Endpoint

"endpoint": "/user/posts"

Parameters

unique_id	Yes	TikTok username (without @)
count	No	Number of videos to return (default: 30)

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/user/posts",
    "params": {
      "unique_id": "nike",
      "count": 10
    }
  }'

Search Users

Search for TikTok users by keyword and get profile information for matching accounts.

Endpoint

"endpoint": "/user/search"

Parameters

keyword	Yes	Search keyword for usernames
count	No	Number of results (default: 10)

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/user/search",
    "params": {
      "keyword": "dancer"
    }
  }'

Search Videos

Search for TikTok videos by keyword and get video metadata, statistics, and download links.

Endpoint

"endpoint": "/feed/search"

Parameters

keyword	Yes	Search keyword for videos
count	No	Number of results (default: 10)

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/feed/search",
    "params": {
      "keyword": "dance challenge"
    }
  }'

Music Info

Get TikTok music/sound information including title, author, duration, and play count.

Endpoint

"endpoint": "/music/info"

Parameters

music_id

Yes

TikTok music/sound ID

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/music/info",
    "params": {
      "music_id": "7123456789012345678"
    }
  }'

Music Posts

Get all TikTok videos that use a specific music/sound track.

Endpoint

"endpoint": "/music/posts"

Parameters

music_id	Yes	TikTok music/sound ID
count	No	Number of videos (default: 10)

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/music/posts",
    "params": {
      "music_id": "7123456789012345678"
    }
  }'

Video Comments

Extract comments from any TikTok video including comment text, author, likes, and timestamps.

Endpoint

"endpoint": "/comment/list"

Parameters

aweme_id	Yes	Video ID (from video URL or video info response)
count	No	Number of comments (default: 20)

Example Request

curl -X POST "https://scrapingbot.io/api/v1/tiktok" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/comment/list",
    "params": {
      "aweme_id": "7123456789012345678"
    }
  }'

Response Format

TikTok API responses follow this structure:

{
  "success": true,
  "data": {
    // Endpoint-specific data
    // (video info, user info, posts, or comments)
  },
  "processed_time": 1.23,
  "duration": "1.23"
}

Pricing

1 Credit

per TikTok request

Free tier includes 1,000 credits = 1,000 TikTok requests per month. View all plans →

Instagram API - Introduction

Extract Instagram user profiles, posts, reels, stories, and media information. No Instagram login required. Access public data from any Instagram account or post.

Endpoint: POST https://scrapingbot.io/api/v1/instagram

Cost: 5 credits per request

User Endpoints

/user/by_id

User profile by ID

/user/by_username

Full user profile

/medias/by_user_id

User's posts

/medias/tagged_by_user_id

Tagged posts

/reels/by_user_id

User's reels

Media Endpoints

/media/by_url

Post by URL

/media/by_shortcode

Post by shortcode

/comments/media_comments_by_id

Media comments

Search Endpoints

/search/users_by_keyword

Search users

/search/hashtags_by_keyword

Search hashtags

/search/places_by_keyword

Search places

Authentication

Include your API key in the x-api-key header.

-H "x-api-key: YOUR_API_KEY"

Quick Start

Get User Profile

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/user/by_username",
    "params": {
      "username": "instagram"
    }
  }'

User by ID

Get user profile information using Instagram user ID. If a username is passed instead, the request is automatically resolved using the username lookup.

Endpoint

"endpoint": "/user/by_id"

Parameters

user_id

Yes

Instagram user ID. Usernames sent here are handled automatically.

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/user/by_id",
    "params": {
      "user_id": "25025320"
    }
  }'

User by Username

Get comprehensive user profile data including follower count, following count, bio, profile picture, and verification status. Numeric IDs sent here are automatically routed to the ID lookup.

Endpoint

"endpoint": "/user/by_username"

Parameters

username

Yes

Instagram username (without @). Numeric IDs are also accepted.

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/user/by_username",
    "params": {
      "username": "nike"
    }
  }'

User Posts

Retrieve a user's recent Instagram posts with captions, likes, comments, images, and videos. Use the returned page_info.end_cursor value to paginate through additional results.

Endpoint

"endpoint": "/medias/by_user_id"

Parameters

user_id	Yes	Instagram user ID (from user profile response)
count	No	Number of posts requested (Instagram currently returns up to 12 per page)
end_cursor	No	Pagination cursor returned in `page_info.end_cursor` from the previous response

Leave end_cursor empty on the first request. To fetch the next page, send the previous page_info.end_cursor value back with the same user_id.

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/medias/by_user_id",
    "params": {
      "user_id": "25025320",
      "count": 12,
      "end_cursor": "QVFBRndET3gyNVlhbTZLVmF1d3ByaHdUQjdKazIxNmRRU1dELU1aQ0xPc295ZHNOVTNzYnR0QkpjRUtZRTMzdE90RE5PNFVJSEphMzNVMC1wNDc3UkZVbQ=="
    }
  }'

User Reels

Extract a user's Instagram Reels with video links, view counts, and engagement metrics. Use the returned paging_info.max_id value to paginate through additional results.

Endpoint

"endpoint": "/reels/by_user_id"

Parameters

user_id	Yes	Instagram user ID
count	No	Number of reels requested (Instagram currently returns up to 12 per page)
max_id	No	Pagination cursor returned in `paging_info.max_id` from the previous response

Leave max_id empty on the first request. To fetch the next page, send the previous paging_info.max_id value back with the same user_id.

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/reels/by_user_id",
    "params": {
      "user_id": "25025320",
      "count": 12,
      "max_id": "QVFBVWZ3M0pGUnVKRjMzM1Q0NWVZZWp4a3psaXM0MTBEN0Q2Z2VKY0k1SWVoSVFCVk9wTzFIMnZPazV6LXdjbjdLZXFSdnJ6c2R1el9BUk80ZmUtcUstUA=="
    }
  }'

Tagged Posts

Get posts where a user is tagged, including photos and videos from other accounts. Use the returned page_info.end_cursor value to paginate through additional results.

Endpoint

"endpoint": "/medias/tagged_by_user_id"

Parameters

user_id	Yes	Instagram user ID
count	No	Number of posts (default: 12, maximum: 12)
end_cursor	No	Pagination cursor returned in `page_info.end_cursor` from the previous response

Leave end_cursor empty on the first request. To fetch more than 12 tagged posts, keep count at 12 or lower and send the cursor from the previous page.

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/medias/tagged_by_user_id",
    "params": {
      "user_id": "25025320",
      "count": 12,
      "end_cursor": "1248024676977729807"
    }
  }'

Media by URL

Get full post information from any Instagram post URL including images, videos, captions, likes, and comments.

Endpoint

"endpoint": "/media/by_url"

Parameters

url

Yes

Full Instagram post URL

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/media/by_url",
    "params": {
      "url": "https://www.instagram.com/p/ABC123xyz/"
    }
  }'

Media by Shortcode

Get post information using Instagram shortcode (the code in /p/SHORTCODE/).

Endpoint

"endpoint": "/media/by_shortcode"

Parameters

shortcode

Yes

Instagram post shortcode

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/media/by_shortcode",
    "params": {
      "shortcode": "ABC123xyz"
    }
  }'

Media Comments

Extract comments from any Instagram post including comment text, author, likes, and timestamps. Use the returned page_info.end_cursor value to paginate through additional comments.

Endpoint

"endpoint": "/comments/media_comments_by_id"

Parameters

media_id	Yes	Instagram media ID
end_cursor	No	Pagination cursor returned in `page_info.end_cursor` from the previous response

Leave end_cursor empty on the first request. When paginating comments, copy the full page_info.end_cursor string exactly as returned.

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/comments/media_comments_by_id",
    "params": {
      "media_id": "3854796740277763042",
      "end_cursor": "{\"cached_comments_cursor\":\"18089619665138394\",\"bifilter_token\":\"...\"}"
    }
  }'

Search Users

Search for Instagram users by keyword and get matching profiles.

Endpoint

"endpoint": "/search/users_by_keyword"

Parameters

keyword

Yes

Search keyword

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/search/users_by_keyword",
    "params": {
      "keyword": "photographer"
    }
  }'

Search Hashtags

Search for Instagram hashtags and get hashtag information including post count.

Endpoint

"endpoint": "/search/hashtags_by_keyword"

Parameters

keyword

Yes

Search keyword

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/search/hashtags_by_keyword",
    "params": {
      "keyword": "travel"
    }
  }'

Search Places

Search for Instagram locations/places by keyword.

Endpoint

"endpoint": "/search/places_by_keyword"

Parameters

keyword

Yes

Location name to search

Example Request

curl -X POST "https://scrapingbot.io/api/v1/instagram" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/search/places_by_keyword",
    "params": {
      "keyword": "New York"
    }
  }'

Response Format

Instagram API responses return data in this format:

{
  "success": true,
  "data": {
    // Endpoint-specific data
    // (user profile, posts, reels, or media info)
  },
  "duration": "1.23"
}

Pricing

5 Credits

per Instagram request

Free tier includes 1,000 credits = 200 Instagram requests per month. View all plans →

Amazon API - Introduction

Query Amazon products, reviews, offers, sellers, deals, identifier conversion, and category trees through the same dedicated ScrapingBot API pattern used by the other platform integrations.

Endpoint: POST https://scrapingbot.io/api/v1/amazon

Cost: 10 credits per request

Current public surface: 14 supported Amazon endpoints

Endpoint Coverage

The current Amazon surface focuses on the supported endpoints that are available in the public docs and dashboard playground, all behind the same request shape: {"endpoint","params"}.

Use keyword and category endpoints for discovery, ASIN endpoints for product enrichment and reviews, seller endpoints for marketplace monitoring, and deals endpoints for discount tracking.

Authentication

Authenticate every request with your ScrapingBot API key using the x-api-key header.

-H "x-api-key: YOUR_API_KEY"

Quick Start

Product Search

curl -X POST "https://scrapingbot.io/api/v1/amazon" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/search",
    "params": {
      "query": "wireless earbuds",
      "country": "US",
      "language": "en_US",
      "page": "1"
    }
  }'

Product Details

curl -X POST "https://scrapingbot.io/api/v1/amazon" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "/product-details",
    "params": {
      "asin": "B07ZPKN6YR",
      "country": "US"
    }
  }'

Endpoint List

/search

Keyword product search

/products-by-category

Products for a category or browse node

/product-details

Amazon product detail page data

/product-reviews

Review lists for an ASIN

/top-product-reviews

Curated or top-ranked reviews

/product-offers

Offer and seller pricing data

/seller-profile

Seller storefront/profile info

/seller-reviews

Seller feedback and ratings

/seller-products

Products listed by a seller

/deals-v2

Current Amazon deals

/deal-products

Products inside a deal

/promo-code-details

Promo code page details

/asin-to-gtin

Identifier conversion

/product-category-list

Category trees and browse nodes

Common Params

Param	Description
country	Marketplace country code like `US`, `CA`, `GB`, `DE`.
language	Locale string such as `en_US` or `de_DE` when supported by the endpoint.
page	Pagination page number for list endpoints.
fields	Optional passthrough field selector when supported upstream.
sort_by	Sort order for search and review-related endpoints.

Endpoint-Specific Required Params

Endpoint	Required Param(s)
/search	query
/products-by-category	category_id
/product-details	asin
/product-reviews	asin
/top-product-reviews	asin
/product-offers	asin
/seller-profile	seller_id
/seller-reviews	seller_id
/seller-products	seller_id
/deals-v2	No fixed required param
/deal-products	deal_id
/promo-code-details	promo_code or url
/asin-to-gtin	asin
/product-category-list	No fixed required param

Sample Responses & Response-Shape Notes

Search-style response

{
  "success": true,
  "data": {
    "products": [
      {
        "asin": "B07ZPKN6YR",
        "title": "Sample Product",
        "price": "$49.99",
        "rating": 4.6
      }
    ]
  },
  "pagination": {
    "page": 1
  },
  "duration": "1.23"
}

Review-style response

{
  "success": true,
  "data": {
    "reviews": [
      {
        "review_id": "R1ABCDE12345",
        "title": "Works well",
        "rating": 5,
        "verified_purchase": true
      }
    ]
  },
  "duration": "1.08"
}

Cookie nuance: The upstream docs suggest cookie for /product-reviews, but live verification showed the endpoint can return 200 without it for some ASINs, so the param is optional in this version.

Response shape varies by endpoint. Some payloads come back as lists inside data.products or data.reviews, while others return a flatter object or different collection keys. The dashboard tester is built to handle both object and list-oriented responses.

Pricing

10 Credits

per Amazon request

Free tier includes 1,000 credits = 100 Amazon requests per month. View all plans →

Need help? Have questions?

Create Free Account →