Scrape.do

https://scrape.do/documentation
Admin
Scrape.do is a web scraping service designed to bypass blocking issues by making bot traffic appear...
Tokens:167,906
Snippets:1,303
Trust Score:8.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Amazon Search API Request Examples

Source: https://scrape.do/documentation/amazon-scraper-api/search

Examples demonstrating how to construct and send a GET request to the Amazon search endpoint with required parameters.

```bash
curl --location --request GET 'https://api.scrape.do/plugin/amazon/search?token=<SDO-token>&keyword=laptop%20stands&geocode=US&page=1'
```

```python
import requests
import json

token = "<SDO-token>"
keyword = "laptop stands"
geocode = "US"
page = 1

url = f"https://api.scrape.do/plugin/amazon/search?token={token}&keyword={keyword}&geocode={geocode}&page={page}"

response = requests.request("GET", url)

print(json.dumps(response.json(), indent=2))
```

```javascript
const axios = require('axios');

const token = "<SDO-token>";
const keyword = encodeURIComponent("laptop stands");
const geocode = "US";
const page = 1;

const url = `https://api.scrape.do/plugin/amazon/search?token=${token}&keyword=${keyword}&geocode=${geocode}&page=${page}`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

```go
package main

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

func main() {
    token := "<SDO-token>"
    keyword := url.QueryEscape("laptop stands")
    geocode := "US"
    page := 1

    apiUrl := fmt.Sprintf(
        "https://api.scrape.do/plugin/amazon/search?token=%s&keyword=%s&geocode=%s&page=%d",
        token, keyword, geocode, page,
    )

    resp, err := http.Get(apiUrl)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

```ruby
require 'net/http'
require 'json'
require 'uri'

token = "<SDO-token>"
keyword = URI.encode_www_form_component("laptop stands")
geocode = "US"
page = 1

url = URI("https://api.scrape.do/plugin/amazon/search?token=#{token}&keyword=#{keyword}&geocode=#{geocode}&page=#{page}")

response = Net::HTTP.get(url)

puts JSON.pretty_generate(JSON.parse(response))
```

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class AmazonSearch {
    public static void main(String[] args) throws Exception {
        String token = "<SDO-token>";
        String keyword = URLEncoder.encode("laptop stands", "UTF-8");
        String geocode = "US";
        int page = 1;

        String url = String.format(
            "https://api.scrape.do/plugin/amazon/search?token=%s&keyword=%s&geocode=%s&page=%d",
            token, keyword, geocode, page
        );

        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");

        BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();

        System.out.println(response.toString());
    }
}
```

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

class Program
{
    static async Task Main()
    {
        string token = "<SDO-token>";
        string keyword = HttpUtility.UrlEncode("laptop stands");
        string geocode = "US";
        int page = 1;

        string url = $"https://api.scrape.do/plugin/amazon/search?token={token}&keyword={keyword}&geocode={geocode}&page={page}";

        using HttpClient client = new HttpClient();
        string response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}
```

```php
<?php
$token = "<SDO-token>";
$keyword = urlencode("laptop stands");
$geocode = "US";
$page = 1;

$url = "https://api.scrape.do/plugin/amazon/search?token={$token}&keyword={$keyword}&geocode={$geocode}&page={$page}";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo json_encode(json_decode($response), JSON_PRETTY_PRINT);
?>
```

--------------------------------

### C# Example

Source: https://scrape.do/documentation/api-response/device

Example of how to use the device parameter with C# and Flurl.

```APIDOC
## C# Request

### Description
This example shows how to use the C# Flurl library to send an asynchronous GET request, scrape a URL, and emulate a mobile device.

### Code
```csharp
using System;
using System.Threading.Tasks;
using Flurl;
using Flurl.Http;

class Program
{
  static async Task Main()
  {
    var token = "YOUR_TOKEN";
    try
    {
      var response = await "http://api.scrape.do/"
        .SetQueryParam("token", token)
        .SetQueryParam("url", "https://httpbin.co/headers")
        .SetQueryParam("device", "mobile")
        .GetAsync();

      Console.WriteLine($"Response status: {response.StatusCode}");
      var content = await response.GetStringAsync();
      Console.WriteLine(content);
    }
    catch (FlurlHttpException ex)
    {
      Console.WriteLine($"Response status: {ex.StatusCode}");
      var error = await ex.GetResponseStringAsync();
      Console.WriteLine(error);
    }
  }
}
```
```

--------------------------------

### Take a Normal Screenshot (C#)

Source: https://scrape.do/documentation/headless-browser/screenshot

This C# example shows how to make an HTTP GET request to capture a screenshot. It prepares the request URL with necessary parameters.

```csharp
string token = "YOUR_TOKEN";
string url = WebUtility.UrlEncode("http://example.com/");
var client = new HttpClient();
var requestURL = $"https://api.scrape.do/?token={token}&url={url}&screenShot=true&render=true&returnJSON=true";
var request = new HttpRequestMessage(HttpMethod.Get, requestURL);

```

--------------------------------

### Node.js Example

Source: https://scrape.do/documentation/api-response/device

Example of how to use the device parameter with Node.js and axios.

```APIDOC
## Node.js Request

### Description
This example demonstrates making a GET request using Node.js and the `axios` library to scrape a URL while emulating a mobile device.

### Code
```javascript
const axios = require("axios");

const params = new URLSearchParams({
  "token": "YOUR_TOKEN",
  "url": "https://httpbin.co/headers",
  "device": "mobile",
});

axios({
  method: 'get',
  url: `https://api.scrape.do/?${params.toString()}`,
  headers: {}
})
  .then((response) => {
    console.log('Response status:', response.status);
    console.log('Response Data:', response.data);
  })
  .catch((error) => {
    console.error('Error:', error.message);
  });
```
```

--------------------------------

### API Pagination Request

Source: https://scrape.do/documentation/google-scraper-api/search/search

Example of a URL request for the second page of results using the 'start' parameter.

```text
/plugin/google/search?token=...&q=pizza+new+york&start=10
```

--------------------------------

### Ruby Example

Source: https://scrape.do/documentation/api-response/device

Example of how to use the device parameter with Ruby and HTTParty.

```APIDOC
## Ruby Request

### Description
This example shows how to use the Ruby `httparty` gem to send a GET request and scrape a URL while emulating a mobile device.

### Code
```ruby
require 'httparty'
require 'json'
require 'cgi/escape'

HTTParty::Basement.default_options.update(verify: false)

response = HTTParty.get('https://api.scrape.do',  
  query: {
    token: 'YOUR_TOKEN',
    url: 'https://httpbin.co/headers',
    'device': 'mobile'
  },
  headers: {})

puts "Response status: #{response.code}"
puts response.body
```
```

--------------------------------

### Java Example

Source: https://scrape.do/documentation/api-response/device

Example of how to use the device parameter with Java's HttpClient.

```APIDOC
## Java Request

### Description
This example demonstrates using Java's built-in `HttpClient` to make a GET request, scrape a URL, and emulate a mobile device.

### Code
```java
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.apache.hc.core5.net.URIBuilder; // Note: This example uses Apache HC5 URIBuilder for easier parameter handling.

public class Main {
    public static void main(String[] args) throws IOException, InterruptedException, URISyntaxException {
        String token = "YOUR_TOKEN";
        HttpClient client = HttpClient.newHttpClient();

        URI uri = new URIBuilder("https://api.scrape.do/")
            .addParameter("token", token)
            .addParameter("url", "https://httpbin.co/headers")
            .addParameter("device", "mobile")
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(uri)
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Response status: " + response.statusCode());
        System.out.println(response.body());
    }
}
```
```

--------------------------------

### Fetch Reviews Examples

Source: https://scrape.do/documentation/google-scraper-api/play-store

Basic implementation examples for fetching app reviews across various programming languages.

```bash
curl --location --request GET 'https://api.scrape.do/plugin/google/play-store/reviews?token=<SDO-token>&product_id=com.tapblaze.coffeebusiness'
```

```python
import requests
import json

token = "<SDO-token>"

url = f"https://api.scrape.do/plugin/google/play-store/reviews?token={token}&product_id=com.tapblaze.coffeebusiness"

response = requests.request("GET", url)

print(json.dumps(response.json(), indent=2))
```

```javascript
const axios = require('axios');

const token = "<SDO-token>";

const url = `https://api.scrape.do/plugin/google/play-store/reviews?token=${token}&product_id=com.tapblaze.coffeebusiness`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

```go
package main

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

func main() {
	token := "<SDO-token>"

	url := fmt.Sprintf(
		"https://api.scrape.do/plugin/google/play-store/reviews?token=%s&product_id=com.tapblaze.coffeebusiness",
		token,
	)

	resp, err := http.Get(url)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}
```

```ruby
require 'net/http'
require 'json'

token = "<SDO-token>"

url = URI("https://api.scrape.do/plugin/google/play-store/reviews?token=#{token}&product_id=com.tapblaze.coffeebusiness")

response = Net::HTTP.get(url)

puts JSON.pretty_generate(JSON.parse(response))
```

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class PlayStoreReviews {
    public static void main(String[] args) throws Exception {
        String token = "<SDO-token>";

        String url = String.format(
            "https://api.scrape.do/plugin/google/play-store/reviews?token=%s&product_id=com.tapblaze.coffeebusiness",
            token
        );

        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");

        BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream())
        );
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();

        System.out.println(response.toString());
    }
}
```

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string token = "<SDO-token>";

        string url = $"https://api.scrape.do/plugin/google/play-store/reviews?token={token}&product_id=com.tapblaze.coffeebusiness";

        using HttpClient client = new HttpClient();
        string response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}
```

```php
<?php
$token = "<SDO-token>";

$url = "https://api.scrape.do/plugin/google/play-store/reviews?token={$token}&product_id=com.tapblaze.coffeebusiness";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo json_encode(json_decode($response), JSON_PRETTY_PRINT);
?>
```

```bash
curl "https://api.scrape.do/plugin/google/play-store/reviews?token=$TOKEN&product_id=com.tapblaze.coffeebusiness"
```

--------------------------------

### Fetch Google Maps Place Details using Node.js

Source: https://scrape.do/documentation/google-scraper-api/maps/place

This Node.js example uses the `axios` library to make the API request. Install it using `npm install axios`. Replace `<SDO-token>` with your Scrape.do API token.

```javascript
const axios = require('axios');

const token = "<SDO-token>";
const placeId = "ChIJqU-tg8KHToYRuCE5EsEyHZA";

const url = `https://api.scrape.do/plugin/google/maps/place?token=${token}&place_id=${placeId}`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

--------------------------------

### Perform a basic GET request via Scrape.do

Source: https://scrape.do/documentation

Use these examples to test your API token and verify connectivity to the Scrape.do proxy service.

```curl
curl --location --request GET 'https://api.scrape.do/?token=YOUR_TOKEN&url=https://httpbin.co/anything'
```

```python
import requests
import urllib.parse
token = "YOUR_TOKEN"
targetUrl = urllib.parse.quote("https://httpbin.co/anything")
url = "http://api.scrape.do/?token={}&url={}".format(token, targetUrl)
response = requests.request("GET", url)
print(response.text)
```

```node
const axios = require('axios');
const token = "YOUR_TOKEN";
const targetUrl = encodeURIComponent("https://httpbin.co/anything"); 
const config = {
    'method': 'GET',
    'url': `https://api.scrape.do/?token=${token}&url=${targetUrl}`,
    'headers': {}
};
axios(config)
    .then(function (response) {
        console.log(response.data);
    })
    .catch(function (error) {
        console.log(error);
    });
```

```go
package main

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

func main() {
	token := "YOUR_TOKEN"
	encoded_url := url.QueryEscape("https://httpbin.co/anything")
	url := fmt.Sprintf("https://api.scrape.do/?token=%s&url=%s", token, encoded_url)
	method := "GET"
	client := &http.Client{}
	req, err := http.NewRequest(method, url, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	res, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer res.Body.Close()
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(body))
}
```

```ruby
require "uri"
require "net/http"
require 'cgi'
str =  CGI.escape "https://httpbin.co/anything"
url = URI("https://api.scrape.do/?url=" + str + "&token=YOUR_TOKEN")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
response = https.request(request)
puts response.read_body
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
String encoded_url = URLEncoder.encode("https://httpbin.co/anything", "UTF-8");
Request request = new Request.Builder()
  .url("https://api.scrape.do/?token=YOUR_TOKEN&url=" + encoded_url +"")
  .method("GET", body)
  .build();
Response response = client.newCall(request).execute();
```

```csharp
string token = "YOUR_TOKEN";
string url = WebUtility.UrlEncode("https://httpbin.co/anything");
var client = new HttpClient();
var requestURL = $"https://api.scrape.do/?token={token}&url={url}";        
var request = new HttpRequestMessage(HttpMethod.Get, requestURL);
var response = client.SendAsync(request).Result;
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(content);
```

```php
<?php
$curl = curl_init();
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_HEADER, false);
$data = [
   "url" => "https://httpbin.co/anything",
   "token" => "YOUR_TOKEN",
];
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($curl, CURLOPT_URL, "https://api.scrape.do/?".http_build_query($data));
curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    "Accept: */*",
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;
?>
```

--------------------------------

### Python Example

Source: https://scrape.do/documentation/api-response/device

Example of how to use the device parameter with Python's requests library.

```APIDOC
## Python Request

### Description
This example shows how to send a GET request using the Python `requests` library to scrape a URL and emulate a mobile device.

### Code
```python
import requests
import json
import urllib.parse

token = "YOUR_TOKEN"
params = {
    "token": token,
    "url": "https://httpbin.co/headers",
    "device": "mobile",
}
data = None
url = f"http://api.scrape.do/?{urllib.parse.urlencode(params)}"
method = "GET"
headers = {}

response = requests.request(method, url, headers=headers, data=data)

print(f"Response status: {response.status_code}")
print(response.text)
```
```

--------------------------------

### Install scrapy-scrapedo library

Source: https://scrape.do/documentation/libraries

Command to install the Scrape.do wrapper for Scrapy.

```bash
pip3 install scrapy-scrapedo
```

--------------------------------

### cURL Example

Source: https://scrape.do/documentation/api-response/device

Example of how to use the device parameter with cURL.

```APIDOC
## cURL Request

### Description
This example demonstrates how to make a GET request using cURL to scrape a URL while emulating a mobile device.

### Code
```bash
curl --location 'http://api.scrape.do/?url=https%3A%2F%2Fhttpbin.co%2Fheaders&token=YOUR_TOKEN&device=mobile'
```
```

--------------------------------

### Example Request Parameters

Source: https://scrape.do/documentation/proxies/postal-code

Examples of query string parameters for various geographic locations.

```text
# United States — Beverly Hills area
&super=true&geoCode=us&postalcode=90210

# United States — New York area
&super=true&geoCode=us&zipcode=10001

# United Kingdom — Central London
&super=true&geoCode=gb&postalcode=SW1A1AA

# Germany — Berlin
&super=true&geoCode=de&postalcode=10115

# Japan — Tokyo (Chiyoda)
&super=true&geoCode=jp&postalcode=100-0001
```

--------------------------------

### Make a GET Request with Super Mode (C#)

Source: https://scrape.do/documentation/proxies/super

This C# example uses HttpClient to make a GET request to the Scrape.do API with the 'super' parameter. Ensure 'YOUR_TOKEN' is replaced with your API token and the target URL is URL-encoded.

```csharp
string token = "YOUR_TOKEN";
string url = WebUtility.UrlEncode("https://httpbin.co/anything");
var client = new HttpClient();
var requestURL = $"https://api.scrape.do/?token={token}&url={url}&super=true";
var request = new HttpRequestMessage(HttpMethod.Get, requestURL);
var response = client.SendAsync(request).Result;
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(content);
```

--------------------------------

### Advanced Request Examples

Source: https://scrape.do/documentation/google-scraper-api/gemini

Examples demonstrating URL-encoded prompts and specific use cases like multi-word queries or language-specific responses.

```bash
# Basic prompt
curl "https://api.scrape.do/plugin/gemini/chat?q=hello&token=$TOKEN"

# Multi-word prompt (URL-encode)
curl --get "https://api.scrape.do/plugin/gemini/chat" \
  --data-urlencode "q=Write a haiku about the ocean" \
  --data-urlencode "token=$TOKEN"

# German prompt gets a German reply
curl --get "https://api.scrape.do/plugin/gemini/chat" \
  --data-urlencode "q=Was sind die wichtigsten Nachrichten heute" \
  --data-urlencode "token=$TOKEN"

# Prompt that tends to produce grounded answers with sources
curl --get "https://api.scrape.do/plugin/gemini/chat" \
  --data-urlencode "q=Latest developments in AI with sources" \
  --data-urlencode "token=$TOKEN"
```

--------------------------------

### ChatGPT Chat Request Examples

Source: https://scrape.do/documentation/chatgpt-api

Basic examples of how to query the ChatGPT plugin using various programming languages and tools.

```bash
curl --location --request GET 'https://api.scrape.do/plugin/chatgpt/chat?token=<SDO-token>&q=Explain+how+rainbows+form'
```

```python
import requests
import json

token = "<SDO-token>"

url = f"https://api.scrape.do/plugin/chatgpt/chat?token={token}&q=Explain+how+rainbows+form"

response = requests.request("GET", url)

print(json.dumps(response.json(), indent=2))
```

```javascript
const axios = require('axios');

const token = "<SDO-token>";

const url = `https://api.scrape.do/plugin/chatgpt/chat?token=${token}&q=Explain+how+rainbows+form`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

```go
package main

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

func main() {
	token := "<SDO-token>"

	url := fmt.Sprintf(
		"https://api.scrape.do/plugin/chatgpt/chat?token=%s&q=Explain+how+rainbows+form",
		token,
	)

	resp, err := http.Get(url)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}
```

```ruby
require 'net/http'
require 'json'

token = "<SDO-token>"

url = URI("https://api.scrape.do/plugin/chatgpt/chat?token=#{token}&q=Explain+how+rainbows+form")

response = Net::HTTP.get(url)

puts JSON.pretty_generate(JSON.parse(response))
```

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class ChatGPTChat {
    public static void main(String[] args) throws Exception {
        String token = "<SDO-token>";

        String url = String.format(
            "https://api.scrape.do/plugin/chatgpt/chat?token=%s&q=Explain+how+rainbows+form",
            token
        );

        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");

        BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream())
        );
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();

        System.out.println(response.toString());
    }
}
```

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string token = "<SDO-token>";

        string url = $"https://api.scrape.do/plugin/chatgpt/chat?token={token}&q=Explain+how+rainbows+form";

        using HttpClient client = new HttpClient();
        string response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}
```

```php
<?php
$token = "<SDO-token>";

$url = "https://api.scrape.do/plugin/chatgpt/chat?token={$token}&q=Explain+how+rainbows+form";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo json_encode(json_decode($response), JSON_PRETTY_PRINT);
?>
```

```bash
curl "https://api.scrape.do/plugin/chatgpt/chat?token=$TOKEN&q=Explain+how+rainbows+form"
```

--------------------------------

### ReturnJSON API Request Examples

Source: https://scrape.do/documentation/headless-browser/returnjson

Examples of how to use the returnJSON parameter across various programming languages. Note that render=true is mandatory for this feature.

```curl
curl --location --request GET 'https://api.scrape.do/?token=YOUR_TOKEN&url=https://httpbin.co/anything&render=true&returnJSON=true'
```

```python
import requests
import urllib.parse
token = "YOUR_TOKEN"
targetUrl = urllib.parse.quote("https://httpbin.co/anything")
render = "true"
returnJson = "true"
url = "http://api.scrape.do/?token={}&url={}&render={}&returnJSON={}".format(token, targetUrl,render,returnJson)
response = requests.request("GET", url)
print(response.text)
```

```node
const axios = require('axios');
const token = "YOUR_TOKEN";
const targetUrl = encodeURIComponent("https://httpbin.co/anything");
const render = "true";
const returnJson = "true"
const config = {
    'method': 'GET',
    'url': `https://api.scrape.do/?token=${token}&url=${targetUrl}&render=${render}&returnJSON=${returnJson}`,
    'headers': {}
};
axios(config)
    .then(function (response) {
        console.log(response.data);
    })
    .catch(function (error) {
        console.log(error);
    });
```

```go
package main

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

func main() {
	token := "YOUR_TOKEN"
	encoded_url := url.QueryEscape("https://httpbin.co/anything")
	url := fmt.Sprintf("https://api.scrape.do/?token=%s&url=%s&render=true&returnJSON=true", token, encoded_url)
	method := "GET"
	client := &http.Client{}
	req, err := http.NewRequest(method, url, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	res, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer res.Body.Close()
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(body))
}
```

```ruby
require "uri"
require "net/http"
require 'cgi'
str = CGI.escape "https://httpbin.co/anything"
url = URI("https://api.scrape.do/?url=" + str + "&token=YOUR_TOKEN&render=True&returnJSON=True")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
response = https.request(request)
puts response.read_body
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
String encoded_url = URLEncoder.encode("https://httpbin.co/anything", "UTF-8");
Request request = new Request.Builder()
  .url("https://api.scrape.do/?token=YOUR_TOKEN&url=" + encoded_url + "&render=true&returnJSON=true")
  .method("GET", body)
  .build();
Response response = client.newCall(request).execute();
```

```csharp
string token = "YOUR_TOKEN";
string url = WebUtility.UrlEncode("https://httpbin.co/anything");
var client = new HttpClient();
var requestURL = $"https://api.scrape.do/?token={token}&url={url}&render=true&returnJSON=true";        
var request = new HttpRequestMessage(HttpMethod.Get, requestURL);
var response = client.SendAsync(request).Result;
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(content);
```

```php
<?php
$curl = curl_init();
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_HEADER, false);
$data = [
   "url" => "https://httpbin.co/anything",
   "token" => "YOUR_TOKEN",
   "render"=> "true",
   "returnJSON" => "true"
];
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($curl, CURLOPT_URL, "https://api.scrape.do/?".http_build_query($data));
curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    "Accept: */*",
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;
?>
```

--------------------------------

### Maps Search ll Parameter Examples

Source: https://scrape.do/documentation/google-scraper-api/localization

Examples of valid ll parameter values for various locations and zoom levels.

```text
@40.7580,-73.9855,15z
```

```text
@40.7128,-74.0060,13z
```

```text
@51.5074,-0.0878,14z
```

```text
@35.6595,139.7005,15z
```

```text
@37.7955,-122.3937,14z
```

--------------------------------

### Basic Gemini API Response Example

Source: https://scrape.do/documentation/google-scraper-api/gemini

A minimal response example containing only the prompt, output text, and model information.

```json
{
  "prompt": "Explain quantum entanglement in one sentence",
  "output": {
    "text": "Quantum entanglement is a phenomenon where two or more particles share a single quantum state, so measuring one instantly determines the corresponding property of the other, no matter how far apart they are."
  },
  "model": "3.5 Flash"
}
```

--------------------------------

### Pagination Example

Source: https://scrape.do/documentation/google-scraper-api/play-store

Demonstrates how to fetch subsequent pages of reviews using the next_page_token.

```bash
# First page of reviews
curl "https://api.scrape.do/plugin/google/play-store/reviews?token=$TOKEN&product_id=com.tapblaze.coffeebusiness"

# Next page using the returned token
curl "https://api.scrape.do/plugin/google/play-store/reviews?token=$TOKEN&product_id=com.tapblaze.coffeebusiness&next_page_token=CrkBIrAB..."
```

--------------------------------

### Example: Get Place Identifier from Search

Source: https://scrape.do/documentation/google-scraper-api/maps/place

Before fetching place details, you need an identifier. This example shows how to call the Search endpoint to get a list of places and extract a `place_id` or `data_cid` from the results.

```curl
curl "https://api.scrape.do/plugin/google/maps/search?q=new+york+pizza&token=YOUR_TOKEN"
```

--------------------------------

### Localized Product Requests

Source: https://scrape.do/documentation/google-scraper-api/play-store

Examples demonstrating how to use localization parameters to fetch data for specific regions and languages.

```bash
# Default (US / English)
curl "https://api.scrape.do/plugin/google/play-store/product?token=$TOKEN&product_id=com.discord"

# Localized to Germany
curl "https://api.scrape.do/plugin/google/play-store/product?token=$TOKEN&product_id=com.duolingo&gl=de&hl=de"
```

--------------------------------

### Make a GET Request with Super Mode (Node.js)

Source: https://scrape.do/documentation/proxies/super

This Node.js example uses the 'axios' library to make a GET request to the Scrape.do API with the 'super' parameter. Remember to replace 'YOUR_TOKEN' with your API token and encode the target URL.

```javascript
const axios = require('axios');
const token = "YOUR_TOKEN";
const targetUrl = encodeURIComponent("https://httpbin.co/anything");
const superParam = "true";
const config = {
    'method': 'GET',
    'url': `https://api.scrape.do/?token=${token}&url=${targetUrl}&super=${superParam}`,
    'headers': {}
};
ějšíaxios(config)
    .then(function (response) {
        console.log(response.data);
    })
    .catch(function (error) {
        console.log(error);
    });
```

--------------------------------

### GET /plugin/google/maps/reviews

Source: https://scrape.do/documentation/google-scraper-api/maps

Retrieve paginated user reviews with ratings, text, images, guided details, topics, and owner responses.

```APIDOC
## GET /plugin/google/maps/reviews

### Description
Paginated user reviews with ratings, text, images, guided details, topics, and owner responses.

### Method
GET

### Endpoint
/plugin/google/maps/reviews

### Query Parameters
- **token** (string) - Required - Your Scrape.do API token.
```

--------------------------------

### Full Workflow Example for Google Maps Place API

Source: https://scrape.do/documentation/google-scraper-api/maps/place

This example demonstrates a complete workflow using cURL and jq to interact with the Google Maps API. It covers searching for a place, fetching detailed information, and retrieving paginated reviews. Ensure you replace 'YOUR_TOKEN' with your actual API token and 'ChIJFTdlBPAoTIYRoJO88NsExVc' with a valid place ID.

```bash
TOKEN="YOUR_TOKEN"

# 1. Search for a place
curl -s "https://api.scrape.do/plugin/google/maps/search?q=best+pizza+nyc&token=$TOKEN" \
  | jq '.local_results[0] | {title, place_id, data_cid}'
```

```bash
# 2. Fetch enriched details for the top result
PLACE_ID="ChIJFTdlBPAoTIYRoJO88NsExVc"
curl -s "https://api.scrape.do/plugin/google/maps/place?place_id=$PLACE_ID&token=$TOKEN" \
  | jq '{title: .place_results.title, summary: .place_results.summary, menu: .place_results.menu, popular_times_monday: .place_results.popular_times.monday}'
```

```bash
# 3. Get paginated reviews
DATA_ID=$(curl -s "https://api.scrape.do/plugin/google/maps/place?place_id=$PLACE_ID&token=$TOKEN" | jq -r '.place_results.data_id')
curl -s "https://api.scrape.do/plugin/google/maps/reviews?data_id=$DATA_ID&token=$TOKEN" \
  | jq '{place: .place_info.title, topics: [.topics[].keyword], first_review: .reviews[0].snippet}'
```

--------------------------------

### Perform Google Search via API

Source: https://scrape.do/documentation/google-scraper-api/search/search

Examples of sending a GET request to the Scrape.do Google search endpoint using various programming languages.

```bash
curl --location --request GET 'https://api.scrape.do/plugin/google/search?token=<SDO-token>&q=pizza+new+york'
```

```python
import requests
import json

token = "<SDO-token>"
query = "pizza+new+york"

url = f"https://api.scrape.do/plugin/google/search?token={token}&q={query}"

response = requests.request("GET", url)

print(json.dumps(response.json(), indent=2))
```

```javascript
const axios = require('axios');

const token = "<SDO-token>";
const query = "pizza+new+york";

const url = `https://api.scrape.do/plugin/google/search?token=${token}&q=${query}`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

```go
package main

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

func main() {
	token := "<SDO-token>"
	query := "pizza+new+york"

	url := fmt.Sprintf(
		"https://api.scrape.do/plugin/google/search?token=%s&q=%s",
		token, query,
	)

	resp, err := http.Get(url)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}
```

```ruby
require 'net/http'
require 'json'

token = "<SDO-token>"
query = "pizza+new+york"

url = URI("https://api.scrape.do/plugin/google/search?token=#{token}&q=#{query}")

response = Net::HTTP.get(url)

puts JSON.pretty_generate(JSON.parse(response))
```

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class GoogleSearch {
    public static void main(String[] args) throws Exception {
        String token = "<SDO-token>";
        String query = "pizza+new+york";

        String url = String.format(
            "https://api.scrape.do/plugin/google/search?token=%s&q=%s",
            token, query
        );

        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");

        BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream())
        );
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();

        System.out.println(response.toString());
    }
}
```

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string token = "<SDO-token>";
        string query = "pizza+new+york";

        string url = $"https://api.scrape.do/plugin/google/search?token={token}&q={query}";

        using HttpClient client = new HttpClient();
        string response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}
```

```php
<?php
$token = "<SDO-token>";
$query = "pizza+new+york";

$url = "https://api.scrape.do/plugin/google/search?token={$token}&q={$query}";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo json_encode(json_decode($response), JSON_PRETTY_PRINT);
?>
```

--------------------------------

### Basic Product Details Request

Source: https://scrape.do/documentation/google-scraper-api/play-store

Examples of how to fetch app details using various programming languages.

```curl
curl --location --request GET 'https://api.scrape.do/plugin/google/play-store/product?token=<SDO-token>&product_id=com.discord'
```

```python
import requests
import json

token = "<SDO-token>"

url = f"https://api.scrape.do/plugin/google/play-store/product?token={token}&product_id=com.discord"

response = requests.request("GET", url)

print(json.dumps(response.json(), indent=2))
```

```javascript
const axios = require('axios');

const token = "<SDO-token>";

const url = `https://api.scrape.do/plugin/google/play-store/product?token=${token}&product_id=com.discord`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

```go
package main

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

func main() {
	token := "<SDO-token>"

	url := fmt.Sprintf(
		"https://api.scrape.do/plugin/google/play-store/product?token=%s&product_id=com.discord",
		token,
	)

	resp, err := http.Get(url)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}
```

```ruby
require 'net/http'
require 'json'

token = "<SDO-token>"

url = URI("https://api.scrape.do/plugin/google/play-store/product?token=#{token}&product_id=com.discord")

response = Net::HTTP.get(url)

puts JSON.pretty_generate(JSON.parse(response))
```

```java
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class PlayStoreProduct {
    public static void main(String[] args) throws Exception {
        String token = "<SDO-token>";

        String url = String.format(
            "https://api.scrape.do/plugin/google/play-store/product?token=%s&product_id=com.discord",
            token
        );

        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");

        BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream())
        );
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();

        System.out.println(response.toString());
    }
}
```

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string token = "<SDO-token>";

        string url = $"https://api.scrape.do/plugin/google/play-store/product?token={token}&product_id=com.discord";

        using HttpClient client = new HttpClient();
        string response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}
```

```php
<?php
$token = "<SDO-token>";

$url = "https://api.scrape.do/plugin/google/play-store/product?token={$token}&product_id=com.discord";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo json_encode(json_decode($response), JSON_PRETTY_PRINT);
?>
```

```bash
curl "https://api.scrape.do/plugin/google/play-store/product?token=$TOKEN&product_id=com.discord"
```

--------------------------------

### Send Custom Headers with C#

Source: https://scrape.do/documentation/headers-cookies/custom-headers

This C# example uses `HttpClient` to send a GET request with a custom header. The `customHeaders=true` parameter is included in the request URL.

```csharp
string token = "YOUR_TOKEN";
string url = WebUtility.UrlEncode("https://httpbin.co/headers");
var client = new HttpClient();
var requestURL = $"https://api.scrape.do/?token={token}&url={url}&customHeaders=true";        
var request = new HttpRequestMessage(HttpMethod.Get, requestURL);
request.Headers.Add("Test-Header-Key", "TestValue");
var response = client.SendAsync(request).Result;
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(content);
```

--------------------------------

### Implement Scrapy with scrapy-scrapedo

Source: https://scrape.do/documentation/libraries

Example of using the wrapper library to configure Scrape.do parameters like geo-location and browser actions.

```python
from scrapydo import scrapy, scrapedo

class ScrapedoSampleCrawler(scrapy.Spider):
    name = "Scrape-do Sample Crawler"
    def __init__(self):
        super().__init__(scrapedo.RequestParameters(
        token="TOKEN", # Get your Scrape.do token from: dashboard.scrape.do
        params={
            "geoCode":"us",
            "super":False,
            "render":True,
            "playWithBrowser":[
                {"Action":"Click","Selector":"#manpage > div.mp > ul > li:nth-child(3) > a"},
                {"Action":"Wait","Timeout":2000},
                {"Action":"Execute","Execute":"document.URL"}
            ],
        }))
        
    def start_requests(self):
        urls = [
            'https://httpbin.co/',
        ]
        
        for url in urls:
            yield self.Request(url=url, callback=self.parse)
    def parse(self, response):
        print(response.body)
        print("target:",self.target_url(response))
```

--------------------------------

### Send Custom Headers with Node.js (Axios)

Source: https://scrape.do/documentation/headers-cookies/custom-headers

This Node.js example uses the `axios` library to make a GET request with custom headers. The `customHeaders=true` parameter is included in the URL.

```javascript
const axios = require('axios');
const token = "YOUR_TOKEN";
const targetUrl = encodeURIComponent("https://httpbin.co/headers");
const config = {
    'method': 'GET',
    'url': `https://api.scrape.do/?token=${token}&url=${targetUrl}&customHeaders=true`,
    'headers': {
        'Test-Header-Key': 'TestValue',
    }
};
axios(config)
    .then(function (response) {
        console.log(response.data);
    })
    .catch(function (error) {
        console.log(error);
    });
```

--------------------------------

### Google Maps Search API Request (C#)

Source: https://scrape.do/documentation/google-scraper-api/maps/search

Utilize C#'s HttpClient to send a GET request to the Google Maps Search API. This example is asynchronous.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string token = "<SDO-token>";
        string query = "pizza+new+york";

        string url = $"https://api.scrape.do/plugin/google/maps/search?token={token}&q={query}";

        using HttpClient client = new HttpClient();
        string response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}
```

--------------------------------

### Google Maps Search API Request (Node.js)

Source: https://scrape.do/documentation/google-scraper-api/maps/search

Make a GET request to the Google Maps Search API using Node.js and the axios library. Ensure you have 'axios' installed.

```javascript
const axios = require('axios');

const token = "<SDO-token>";
const query = "pizza+new+york";

const url = `https://api.scrape.do/plugin/google/maps/search?token=${token}&q=${query}`;

axios.get(url)
  .then(response => {
    console.log(JSON.stringify(response.data, null, 2));
  })
  .catch(error => {
    console.error(error);
  });
```

--------------------------------

### Download files with Java

Source: https://scrape.do/documentation/api-response/response-output

Use OkHttp to build and execute the GET request.

```java
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
String encoded_url = URLEncoder.encode("https://httpbin.co/image", "UTF-8");
Request request = new Request.Builder()
.url("https://api.scrape.do/?token=YOUR_URL&url=" + encoded_url +"")
.method("GET", body)
.build();
Response response = client.newCall(request).execute();
```
Tokens:
Raw