ScreenshotAPI

https://www.screenshotapi.net/docs
Admin
ScreenshotAPI is an advanced and dynamic solution that allows users to programmatically take...
Tokens:38,948
Snippets:124
Trust Score:8.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Ruby Screenshot Capture

Source: https://www.screenshotapi.net/docs/getStarted

This example shows how to capture a website screenshot using Ruby's `net/http` and `uri` modules. It constructs the query URL, sends a GET request, and saves the screenshot if the response is successful.

```APIDOC
## Ruby Screenshot Capture

### Description
This endpoint captures a website screenshot using Ruby.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your ScreenshotAPI token.
- **url** (string) - Required - The URL of the website to capture.
- **output** (string) - Required - The output format (e.g., 'image').
- **file_type** (string) - Required - The desired file type for the screenshot (e.g., 'png').

### Request Example
```ruby
require "net/http"
require "uri"

# Define your API Key, URL, output type, and file type
token = "Your API key"
url = URI.encode("https://google.com")
output = "image"
file_type = "png"

# Construct the query URL
query = "https://shot.screenshotapi.net/screenshot"
query += "?token=#{token}&url=#{url}&output=#{output}&file_type=#{file_type}"

# Send a GET request to the API
uri = URI.parse(query)
response = Net::HTTP.get_response(uri)

# Check if the response was successful
if response.code == "200"
	# Save the screenshot as a binary file
	File.open("screenshot.png", "wb") do |file|
		file.write(response.body)
	end
	puts "The file was saved!"
else
	puts "Error: #{response.code} - #{response.message}"
end
```

### Response
#### Success Response (200)
- The screenshot image is saved locally.
#### Error Response
- **code** (string) - The error code.
- **message** (string) - The error message.
```

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

### JavaScript Fetch API Screenshot Capture

Source: https://www.screenshotapi.net/docs/getStarted

This example demonstrates how to capture a website screenshot using the JavaScript Fetch API. It sends a GET request to the specified endpoint and logs the response.

```APIDOC
## JavaScript Fetch API Screenshot Capture

### Description
This endpoint captures a website screenshot using the JavaScript Fetch API.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/v3/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your ScreenshotAPI token.
- **url** (string) - Required - The URL of the website to capture.
- **output** (string) - Required - The output format (e.g., 'image').
- **file_type** (string) - Required - The desired file type for the screenshot (e.g., 'png').

### Request Example
```javascript
const requestOptions = {
	method : "GET",
	redirect : "follow"
};

fetch (
	"https://shot.screenshotapi.net/v3/screenshot?token={token}&url={url}&output={output}&file_type={file_type}";
	requestOptions
)
.then((response) => response.text())
.then((result) => console.log(result))
.catch((error) => console.error(error));
```

### Response
- The response body will contain the screenshot data or an error message.
```

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

### Capture Screenshot with Ruby

Source: https://www.screenshotapi.net/docs/getStarted

This Ruby example demonstrates capturing a screenshot using the Screenshot API. It constructs the request URL with the provided API token, target URL, output format, and file type. The `Net::HTTP` library is used to make the GET request, and the response body is saved to a file named 'screenshot.png'. Error handling is included for the HTTP request.

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

# @param token [String] Your API Key
# @param url [String] The URL to screenshot (will be URL-encoded)
# @param output [String] The output format ('image' or 'json')
# @param file_type [String] The type of image file ('png', 'jpg', etc.)
token = 'Your API Key'
url_to_screenshot = 'https://google.com'
output_format = 'image'
file_extension = 'png'

# URL-encode the target URL
encoded_url = URI.encode_www_form_component(url_to_screenshot)

# Construct the full API request URI
uri = URI.parse("https://shot.screenshotapi.net/screenshot")
uri.query = "token=#{token}&url=#{encoded_url}&output=#{output_format}&file_type=#{file_extension}"

# Make the HTTP GET request
response = Net::HTTP.get_response(uri)

# Check if the request was successful
if response.is_a?(Net::HTTPSuccess)
  # Save the screenshot to a file
  File.open("screenshot.#{file_extension}", "wb") do |file|
    file.write(response.body)
    puts "Screenshot saved to screenshot.#{file_extension}"
  end
else
  puts "Failed to capture screenshot. Status code: #{response.code}"
  puts "Response body: #{response.body}"
end
```

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

### Capture Screenshot with Go

Source: https://www.screenshotapi.net/docs/getStarted

This Go program illustrates capturing a screenshot using the Screenshot API. It constructs the URL with provided parameters (token, URL, output, file type) and makes an HTTP GET request. The response body, which is the image data, is then saved to a file named 'screenshot.png'. Error handling is included for the API call and file operations.

```go
package main

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

func main() {
 	// @param {String} token - String containing your API Key 
 	// @param {String} url - Encoded URI string container the URI you're targeting
 	// @param {String} output - String specifying the output format, 'image' or 'json'
 	// @param {String} file_type - String specifying the output type   
	token := "Your API Key"
	url := url2.QueryEscape("https://google.com")
	output := "image"
	file_type := "png"

 	// Construct the query params and URL
	query := "https://shot.screenshotapi.net/screenshot"
	query += fmt.Sprintf("?token=%s&url=%s&output=%s&file_type=%s",
		 token, url, output, file_type)

 	// Call the API
	resp, err := http.Get(query)
	 if err != nil{
		 panic(err)
 	}
	 defer resp.Body.Close()

 	// Raise error if call was unsucessfull
 	if resp.StatusCode != 200 {
		 errorBody, _ := ioutil.ReadAll(resp.Body)
		 panic(fmt.Errorf("error while calling api %s", errorBody))
 	}

 	// Save the screenshot
	 file, err := os.Create("./screenshot.png")
	 if err != nil {
		 panic(err)
 	}
	 defer file.Close()

	 _, err = io.Copy(file, resp.Body)
 	if err != nil {
		 panic(err)
 	}
}
```

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

### Ruby: Capture Website Screenshot using Net::HTTP

Source: https://www.screenshotapi.net/docs/getStarted

This Ruby snippet demonstrates how to capture a website screenshot using the `Net::HTTP` library. It constructs the API query URL, sends a GET request, and saves the response body as a PNG file if the request is successful. Remember to replace placeholders with your actual API key and desired URL.

```ruby
require "net/http"\nrequire "uri"\n\n# Define your API Key, URL, output type, and file type\ntoken = "Your API key"\nurl = URI.encode("https://google.com")\noutput = "image"\nfile_type = "png"\n\n# Construct the query URL\nquery = "https://shot.screenshotapi.net/screenshot"\nquery += "?token=#{token}&url=#{url}&output=#{output}&file_type=#{file_type}"\n\n# Send a GET request to the API\uri = URI.parse(query)\nresponse = Net::HTTP.get_response(uri)\n\n# Check if the response was successful\nif response.code == "200"\n\t# Save the screenshot as a binary file\n\tFile.open("screenshot.png", "wb") do |file|\n\t\tfile.write(response.body)\n\tend\n\tputs "The file was saved!"\nelse\n\tputs "Error: #{response.code} - #{response.message}"\nend
```

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

### Ruby Screenshot API Example

Source: https://www.screenshotapi.net/docs/index

Example of how to use the ScreenshotAPI with Ruby to capture a screenshot.

```APIDOC
## GET /screenshot

### Description
Captures a screenshot of a given URL.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your API key
- **url** (string) - Required - The URL of the website to capture
- **output** (string) - Required - The output format (e.g., "image")
- **file_type** (string) - Required - The desired file type for the screenshot (e.g., "png")

### Request Example
```ruby
require "net/http"
require "uri"

# Define your API Key, URL, output type, and file type
token = "Your API key"
url = URI.encode("https://google.com")
output = "image"
file_type = "png"

# Construct the query URL
query = "https://shot.screenshotapi.net/screenshot"
query += "?token=#{token}&url=#{url}&output=#{output}&file_type=#{file_type}"

# Send a GET request to the API
uri = URI.parse(query)
response = Net::HTTP.get_response(uri)

# Check if the response was successful
if response.code == "200"
	# Save the screenshot as a binary file
	File.open("screenshot.png", "wb") do |file|
		file.write(response.body)
	end
	puts "The file was saved!"
else
	puts "Error: #{response.code} - #{response.message}"
end
```

### Response
#### Success Response (200)
Saves the screenshot to the specified file path.

#### Response Example
(No explicit JSON response, saves file directly)
```

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

### Take Screenshot with Go

Source: https://www.screenshotapi.net/docs/index

This Go program illustrates how to get a screenshot using ScreenshotAPI. It constructs the API endpoint URL, performs an HTTP GET request, checks for errors and non-200 status codes, and then saves the response body to a local file named 'screenshot.png'. It uses standard Go libraries for HTTP requests and file operations.

```go
package main

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

func main() {
 	// @param {String} token - String containing your API Key 
 	// @param {String} url - Encoded URI string container the URI you're targeting
 	// @param {String} output - String specifying the output format, 'image' or 'json'
 	// @param {String} file_type - String specifying the output type   
	t token := "Your API Key"
	 url := url2.QueryEscape("https://google.com")
	 output := "image"
	 file_type := "png"

 	// Construct the query params and URL
	 query := "https://shot.screenshotapi.net/screenshot"
	 query += fmt.Sprintf("?token=%s&url=%s&output=%s&file_type=%s",
		 token, url, output, file_type)

 	// Call the API
	 resp, err := http.Get(query)
	 if err != nil{
 		 panic(err)
 	}
 	 defer resp.Body.Close()

 	// Raise error if call was unsucessfull
 	 if resp.StatusCode != 200 {
		 errorBody, _ := ioutil.ReadAll(resp.Body)
		 panic(fmt.Errorf("error while calling api %s", errorBody))
 	}

 	// Save the screenshot
	 file, err := os.Create("./screenshot.png")
	 if err != nil {
		 panic(err)
 	}
 	 defer file.Close()

	 _, err = io.Copy(file, resp.Body)
 	 if err != nil {
		 panic(err)
 	}
}
```

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

### Take Screenshot with PHP

Source: https://www.screenshotapi.net/docs/index

This PHP snippet shows how to take a screenshot using ScreenshotAPI. It constructs the API request URL with authentication token and target URL, then uses `file_get_contents` to fetch the screenshot data and `file_put_contents` to save it as a PNG file. Ensure your PHP installation has allow_url_fopen enabled.

```php
// @param {String} $token - String containing your API Key
// @param {String} $url - Encoded URI string container the URI you're targeting
// @param {String} output - String specifying the output format, "image" or "json"
// @param {String} file_type - String specifying the output type
$token = 'Your API Key';
$url = urlencode('https://google.com');
$output = 'image';
$file_type = 'png';

// Construct the query params and URL
$query = "https://shot.screenshotapi.net/screenshot";
$query .= "?token=$token&url=$url&output=$output&file_type=$file_type";

// Call the API
$image = file_get_contents($query);

// Save the screenshot
file_put_contents('./screenshot.png', $image);
```

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

### Take Screenshot with Node.js

Source: https://www.screenshotapi.net/docs/index

This Node.js snippet demonstrates how to capture a screenshot using the ScreenshotAPI. It utilizes the 'request' library to make an HTTP GET request with API credentials and target URL, then saves the received binary data as a PNG file. Ensure you have the 'request' module installed.

```javascript
var fs = require("fs");
var request = require("request");

// @param {String} token - String containing your API Key
// @param {String} url - Encoded URI string container the URI you're targeting
// @param {String} output - String specifying the output format, 'image' or 'json'
// @param {String} file_type - String specifying the output type
var token = "Your API Key";
var url = encodeURIComponent("https://google.com");
var output = "image";
var file_type = "png";

// Construct the query params and URL
var query = "https://shot.screenshotapi.net/screenshot";
query += `?token=${token}&url=${url}&output=${output}&file_type=${file_type}`;

// Call the API and save the screenshot
request.get({ url: query, encoding: "binary" }, (err, response, body) => {
 	fs.writeFile("screenshot.png", body, "binary", (err) => {
		 if (err) {
			 console.log(err);
 		 } else {
			 console.log("The file was saved!");
 		 }
 	});
});
```

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

### Take Screenshot with Java

Source: https://www.screenshotapi.net/docs/index

This Java example demonstrates taking a screenshot using ScreenshotAPI. It constructs the API URL with parameters, opens a connection to the URL, reads the response stream, and writes it to a local file named 'screenshot.png'. It includes basic exception handling for potential issues during the process.

```java
package main;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLEncoder;

public class Main{

	public static void main(String[] args) {
		try {
			// @param {String} $token - String containing your API Key 
			// @param {String} $url - Encoded URI string container the URI you're targeting 
			// @param {String} $output - String specifying the output format, 'image' or 'json'
			// @param {String} file_type - String specifying the output type
			String token = "Your API Key";
			String url = URLEncoder.encode("https://google.com");
			String output = "image";
			String file_type = "png";

			// Construct the query params and URL
			String query = "https://shot.screenshotapi.net/screenshot";
 			query += String.format("?token=%s&url=%s&output=%s&file_type=%s",
				token, url, output, file_type);
			URL apiUrl = new URL(query);

			// Call the API and save the screenshot
			InputStream inputStream = apiUrl.openStream();
			OutputStream outputStream = new FileOutputStream("./screenshot.png");
			inputStream.transferTo(outputStream);

			inputStream.close();
			outputStream.close();
 		 } catch(Exception ex) {
			ex.printStackTrace();
 		 }
 	}
}
```

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

### Python Screenshot Capture

Source: https://www.screenshotapi.net/docs/getStarted

This example demonstrates how to capture a website screenshot using Python's `urllib.request` module. It constructs the query parameters and URL, then retrieves the screenshot and saves it locally.

```APIDOC
## Python Screenshot Capture

### Description
This endpoint captures a website screenshot using Python.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your ScreenshotAPI token.
- **url** (string) - Required - The URL of the website to capture.
- **output** (string) - Required - The output format (e.g., 'image').
- **file_type** (string) - Required - The desired file type for the screenshot (e.g., 'png').

### Request Example
```python
import urllib.request

token = "YOUR_API_TOKEN"
url = "https://example.com"
output = "image"
file_type = "png"

# Construct the query params and URL
query = "https://shot.screenshotapi.net/screenshot"
query += "?token=%s&url=%s&output=%s&file_type=%s" % (token, url, output, file_type)

# Call the API
urllib.request.urlretrieve(query, "./screenshot.png")
```

### Response
#### Success Response (200)
- The screenshot image is saved locally.
```

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

### JavaScript Screenshot API Example

Source: https://www.screenshotapi.net/docs/index

Example of how to use the ScreenshotAPI with JavaScript (fetch API) to capture a screenshot.

```APIDOC
## GET /v3/screenshot

### Description
Captures a screenshot of a given URL using the v3 endpoint.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/v3/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your API key
- **url** (string) - Required - The URL of the website to capture
- **output** (string) - Required - The output format (e.g., "image")
- **file_type** (string) - Required - The desired file type for the screenshot (e.g., "png")

### Request Example
```javascript
const requestOptions = {
	method : "GET",
	redirect : "follow"
};

fetch (
	"https://shot.screenshotapi.net/v3/screenshot?token={token}&url={url}&output={output}&file_type={file_type}";
	requestOptions
)
.then((response) => response.text())
.then((result) => console.log(result))
.catch((error) => console.error(error));
```

### Response
#### Success Response (200)
Returns the screenshot data or a URL to the screenshot.

#### Response Example
```json
{
  "example": "screenshot data or URL"
}
```
```

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

### Python Screenshot API Example

Source: https://www.screenshotapi.net/docs/index

Example of how to use the ScreenshotAPI with Python to capture a screenshot.

```APIDOC
## GET /screenshot

### Description
Captures a screenshot of a given URL.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your API key
- **url** (string) - Required - The URL of the website to capture
- **output** (string) - Required - The output format (e.g., "image")
- **file_type** (string) - Required - The desired file type for the screenshot (e.g., "png")

### Request Example
```python
import urllib.request

token = "YOUR_API_KEY"
url = "https://www.google.com"
output = "image"
file_type = "png"

# Construct the query params and URL
query = "https://shot.screenshotapi.net/screenshot"
query += "?token=%s&url=%s&output=%s&file_type=%s" % (token, url, output, file_type)

# Call the API
urllib.request.urlretrieve(query, "./screenshot.png")
```

### Response
#### Success Response (200)
Saves the screenshot to the specified file path.

#### Response Example
(No explicit JSON response, saves file directly)
```

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

### Download CSV Output File using Java (OkHttp)

Source: https://www.screenshotapi.net/docs/bulkScreenshots

This Java snippet demonstrates downloading the processed CSV file using the OkHttp client. It sets up the request with the appropriate URL and method (GET), then executes the request and prints the response body. Note that this example uses a placeholder for the request body, which is not strictly necessary for a GET request but included for completeness based on the provided structure.

```java
OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder().url("https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}"
	.method("GET", body)
	.build();
Response response = client.newCall(request)
	.execute();
```

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

### Capture Screenshot with Python

Source: https://www.screenshotapi.net/docs/getStarted

This Python example shows how to capture a screenshot using the Screenshot API. It utilizes the `urllib` module to encode the URL and make the request. The response data is then saved to a file named 'screenshot.png'. Note the SSL context creation to handle potential certificate issues.

```python
import urllib.parse
import urllib.request
import ssl

ssl._create_default_https_context = ssl._create_unverified_context

# @param {String} $token - String containing your API Key
# @param {String} $url - Encoded URI string container the URI you're targeting 
# @param {String} $output - String specifying the output format, 'image' or 'json'
# @param {String} file_type - String specifying the output type
token = "Your API Key"
url = urllib.parse.quote_plus("https://google.com")
output = "image"
file_type = "png"

# Construct the query params and URL
query = "https://shot.screenshotapi.net/screenshot"
query += f"?token={token}&url={url}&output={output}&file_type={file_type}"

# Call the API and save the screenshot
response = urllib.request.urlopen(query)
with open("screenshot.png", "wb") as f:
    f.write(response.read())
```

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

### JavaScript: Capture Website Screenshot using Fetch API

Source: https://www.screenshotapi.net/docs/getStarted

This JavaScript snippet utilizes the `fetch` API to capture a website screenshot. It sends a GET request to the ScreenshotAPI endpoint with specified parameters. The result is logged to the console, or an error is caught and logged if the request fails. Replace `{token}`, `{url}`, `{output}`, and `{file_type}` with your specific values.

```javascript
const requestOptions = {\nmethod : "GET",\nredirect : "follow"\n};\n\nfetch (\n"https://shot.screenshotapi.net/v3/screenshot?token={token}&url={url}&output={output}&file_type={file_type}";\nrequestOptions\n)\n.then((response) => response.text())\n.then((result) => console.log(result))\n.catch((error) => console.error(error));
```

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

### Google Apps Script: Capture Website Screenshot

Source: https://www.screenshotapi.net/docs/getStarted

This Google Apps Script function, `SCREENSHOT`, takes a website URL and returns a screenshot URL using ScreenshotAPI. It constructs the query, sets request options, and uses `UrlFetchApp.fetch` to get the screenshot URL from the response headers. Remember to replace `YOUR_API_KEY` with your actual ScreenshotAPI key.

```javascript
/**\n\t* Takes a website URL as input and returns a screenshot of the website using the ScreenshotAPI service.\n\t* @param {string} websiteUrl - The URL of the website to take a screenshot of.\n\t* @return {string} screenshotUrl - The URL of the screenshot image.\n\t* @customfunction\n\t*/ \n   \nasync function SCREENSHOT(websiteUrl) {\n\tconst YOUR_API_KEY = "XXXXXXX-XXXXXXX-XXXXXXX-XXXXXXX"; // Your ScreenshotAPI API key\n\tconst query = "https://shot.screenshotapi.net/v3/screenshot?token={YOUR_API_KEY}&url={websiteUrl} &output=image&file_type=png"; // Construct the query params and URL\n\tconst options = {\n\t"method" : "get",\n\t"contentType": "application/json",\n\t"followRedirects":false\n\t}; // The options for the fetch request\n   \n\tconst response = await UrlFetchApp.fetch(query,options); // Make the fetch request to ScreenshotAPI\n\tconst screenshotUrl = response.getHeaders()["Location"]; // Get the URL of the screenshot from the response headers\n\treturn screenshotUrl; // Return the URL of the screenshot\n}
```

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

### Capture Screenshot with PHP

Source: https://www.screenshotapi.net/docs/getStarted

This PHP example shows how to capture a screenshot via the Screenshot API. It uses built-in functions like `urlencode`, `file_get_contents`, and `file_put_contents` to construct the request and save the image. The parameters include your API token, the target URL, desired output format, and file type.

```php
// @param {String} $token - String containing your API Key 
// @param {String} $url - Encoded URI string container the URI you're targeting 
// @param {String} output - String specifying the output format, "image" or "json"
// @param {String} file_type - String specifying the output type
$token = 'Your API Key';
$url = urlencode('https://google.com');
$output = 'image';
$file_type = 'png';

// Construct the query params and URL
$query = "https://shot.screenshotapi.net/screenshot";
$query .= "?token=$token&url=$url&output=$output&file_type=$file_type";

// Call the API
$image = file_get_contents($query);

// Save the screenshot
file_put_contents('./screenshot.png', $image);
```

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

### Ruby: Capture Screenshot with Net::HTTP

Source: https://www.screenshotapi.net/docs/index

Captures a website screenshot using Ruby's Net::HTTP library. It constructs the API query URL, sends a GET request, and saves the screenshot to a file if the request is successful. Handles potential API errors by checking the response code.

```ruby
require "net/http"
require "uri"

# Define your API Key, URL, output type, and file type
token = "Your API key"
url = URI.encode("https://google.com")
output = "image"
file_type = "png"

# Construct the query URL
query = "https://shot.screenshotapi.net/screenshot"
query += "?token=#{token}&url=#{url}&output=#{output}&file_type=#{file_type}"

# Send a GET request to the API
uri = URI.parse(query)
response = Net::HTTP.get_response(uri)

# Check if the response was successful
if response.code == "200"
	# Save the screenshot as a binary file
	File.open("screenshot.png", "wb") do |file|
		file.write(response.body)
	end
	puts "The file was saved!"
else
	puts "Error: #{response.code} - #{response.message}"
end
```

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

### JavaScript: Capture Screenshot with Fetch API

Source: https://www.screenshotapi.net/docs/index

Captures a website screenshot using the JavaScript Fetch API. It sends a GET request to the ScreenshotAPI endpoint with specified parameters and logs the result or error to the console. Note: This example logs the raw response text, which might not be the image itself.

```javascript
const requestOptions = {
method : "GET",
redirect : "follow"
};

fetch (
"https://shot.screenshotapi.net/v3/screenshot?token={token}&url={url}&output={output}&file_type={file_type}";
requestOptions
)
.then((response) => response.text())
.then((result) => console.log(result))
.catch((error) => console.error(error));
```

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

### Screenshot API Endpoint

Source: https://www.screenshotapi.net/docs/getStarted

This endpoint allows you to capture a screenshot of a given URL. You can specify the output format and file type.

```APIDOC
## GET /screenshot

### Description
Captures a screenshot of a specified URL with options for output format and file type.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/screenshot

### Parameters
#### Query Parameters
- **token** (String) - Required - Your API Key.
- **url** (String) - Required - The URI string you're targeting, URL-encoded.
- **output** (String) - Optional - Specifies the output format, 'image' or 'json'. Defaults to 'image'.
- **file_type** (String) - Optional - Specifies the output file type (e.g., 'png', 'jpg'). Defaults to 'png' when output is 'image'.

### Request Example (Node.JS)
```javascript
var fs = require("fs");
var request = require("request");

var token = "Your API Key";
var url = encodeURIComponent("https://google.com");
var output = "image";
var file_type = "png";

var query = "https://shot.screenshotapi.net/screenshot";
query += `?token=${token}&url=${url}&output=${output}&file_type=${file_type}`;

request.get({ url: query, encoding: "binary" }, (err, response, body) => {
 	fs.writeFile("screenshot.png", body, "binary", (err) => {
		 if (err) {
			 console.log(err);
 		 } else {
			 console.log("The file was saved!");
 		 }
 	});
});
```

### Request Example (PHP)
```php
$token = 'Your API Key';
$url = urlencode('https://google.com');
$output = 'image';
$file_type = 'png';

$query = "https://shot.screenshotapi.net/screenshot";
$query .= "?token=$token&url=$url&output=$output&file_type=$file_type";

$image = file_get_contents($query);
file_put_contents('./screenshot.png', $image);
```

### Request Example (Go)
```go
package main

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

func main() {
	 token := "Your API Key"
	 url := url2.QueryEscape("https://google.com")
	 output := "image"
	 file_type := "png"

	 query := "https://shot.screenshotapi.net/screenshot"
	 query += fmt.Sprintf("?token=%s&url=%s&output=%s&file_type=%s",
		 token, url, output, file_type)

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

	 if resp.StatusCode != 200 {
		 errorBody, _ := ioutil.ReadAll(resp.Body)
		 panic(fmt.Errorf("error while calling api %s", errorBody))
 	}

	 file, err := os.Create("./screenshot.png")
	 if err != nil {
		 panic(err)
 	}
 	defer file.Close()

	 _, err = io.Copy(file, resp.Body)
 	if err != nil {
		 panic(err)
 	}
}
```

### Request Example (Java)
```java
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLEncoder;

public class Main{

	public static void main(String[] args) {
		try {
			String token = "Your API Key";
			String url = URLEncoder.encode("https://google.com");
			String output = "image";
			String file_type = "png";

			String query = "https://shot.screenshotapi.net/screenshot";
 			query += String.format("?token=%s&url=%s&output=%s&file_type=%s",
				token, url, output, file_type);
			URL apiUrl = new URL(query);

			InputStream inputStream = apiUrl.openStream();
			OutputStream outputStream = new FileOutputStream("./screenshot.png");
			inputStream.transferTo(outputStream);

			inputStream.close();
			outputStream.close();
 		} catch(Exception ex) {
			ex.printStackTrace();
 		}
 	}
}
```

### Request Example (Python)
```python
import urllib.parse
import urllib.request
import ssl

ssl._create_default_https_context = ssl._create_unverified_context

token = "Your API Key"
url = urllib.parse.quote_plus("https://google.com")
output = "image"
file_type = "png"

query = "https://shot.screenshotapi.net/screenshot"
query += f"?token={token}&url={url}&output={output}&file_type={file_type}"

response = urllib.request.urlopen(query)
with open("screenshot.png", "wb") as f:
	f.write(response.read())
```

### Response
#### Success Response (200)
- **image/png** (Binary) - The screenshot image file.
- **application/json** (JSON) - A JSON object containing screenshot data (if `output=json` is specified).

#### Response Example (Image)
(Binary image data)

#### Response Example (JSON)
```json
{
  "success": true,
  "message": "Screenshot captured successfully.",
  "screenshot_url": "/path/to/your/screenshot.png"
}
```
```

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

### Render Screenshot with Go

Source: https://www.screenshotapi.net/docs/renderScreenshot

This Go program makes an HTTP GET request to the ScreenshotAPI to capture a website screenshot. It requires your API token and the target URL. The response body is read and printed to standard output.

```go
package main

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

func main() {
	url := "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https://apple.com"
	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 := io.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}
```

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

### Google Apps Script Custom Function

Source: https://www.screenshotapi.net/docs/getStarted

This example defines a custom function `SCREENSHOT` for Google Apps Script that captures a website screenshot and returns its URL. It uses `UrlFetchApp` to interact with the ScreenshotAPI.

```APIDOC
## Google Apps Script Custom Function

### Description
This custom function for Google Apps Script captures a website screenshot and returns its URL.

### Method
GET

### Endpoint
https://shot.screenshotapi.net/v3/screenshot

### Parameters
#### Query Parameters
- **token** (string) - Required - Your ScreenshotAPI token (replace 'XXXXXXX-XXXXXXX-XXXXXXX-XXXXXXX').
- **websiteUrl** (string) - Required - The URL of the website to capture.
- **output** (string) - Defaults to 'image'.
- **file_type** (string) - Defaults to 'png'.

### Request Example
```javascript
/**
 * Takes a website URL as input and returns a screenshot of the website using the ScreenshotAPI service.
 * @param {string} websiteUrl - The URL of the website to take a screenshot of.
 * @return {string} screenshotUrl - The URL of the screenshot image.
 * @customfunction
 */
function SCREENSHOT(websiteUrl) {
	const YOUR_API_KEY = "XXXXXXX-XXXXXXX-XXXXXXX-XXXXXXX"; // Your ScreenshotAPI API key
	const query = "https://shot.screenshotapi.net/v3/screenshot?token={YOUR_API_KEY}&url={websiteUrl} &output=image&file_type=png"; // Construct the query params and URL
	const options = {
	"method" : "get",
	"contentType": "application/json",
	"followRedirects":false
	}; // The options for the fetch request

	const response = UrlFetchApp.fetch(query,options); // Make the fetch request to ScreenshotAPI
	const screenshotUrl = response.getHeaders()["Location"]; // Get the URL of the screenshot from the response headers
	return screenshotUrl; // Return the URL of the screenshot
}
```

### Response
#### Success Response
- **screenshotUrl** (string) - The URL of the generated screenshot.
```

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

### Render Screenshot with Java (OkHttpClient)

Source: https://www.screenshotapi.net/docs/renderScreenshot

This Java code snippet demonstrates how to use OkHttpClient to send a GET request to the ScreenshotAPI for capturing a website screenshot. It requires your API token and the target URL. The response body is then processed.

```java
OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder().url("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https://apple.com"
	.method("GET", body)
	.build();
Response response = client.newCall(request)
	.execute();
```

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

### Render Screenshot with Python

Source: https://www.screenshotapi.net/docs/renderScreenshot

This Python script uses the 'requests' library to make a GET request to the ScreenshotAPI, enabling website screenshot rendering. Ensure you replace 'TOKEN' with your API key and specify the desired URL. The response text is then printed.

```python
import requests

url = "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https://apple.com"
payload = {}
headers = {}

response = requests.request("GET", url, headers, data=payload)
print(response.text)
```

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

### Render Screenshot with PHP

Source: https://www.screenshotapi.net/docs/renderScreenshot

This PHP snippet utilizes the http client to send a GET request to the ScreenshotAPI for rendering a screenshot. It requires replacing 'TOKEN' with your actual API key and 'https://apple.com' with the desired website URL. The response body is then echoed.

```php
<?php
	$client = new http.Client;
	$request = new http.Client.Request;
	$request->setRequestUrl("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https://apple.com");
	$request->setRequestMethod("GET");
	$request->setOptions(array());

	$client->enqueue($request)->send();
	$response = $client->getResponse();
	echo $response->getBody();
?>
```

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

### Get Cached Screenshot with enable_caching=true

Source: https://www.screenshotapi.net/docs/renderScreenshot

This Python example demonstrates fetching a screenshot with caching enabled using the `requests` library. The API caches the first screenshot, and subsequent requests with default `fresh` parameter will use the cached version. It sends a GET request with empty headers and payload.

```python
import requests

url = "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&fresh=true&output=image&file_type=png&enable_caching=true&wait_for_event=load&[OPTIONS]"
payload = {}
headers = {}

response = requests.request("GET", url, headers, data=payload)
print(response.text)

```

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

### Generate Scrolling Screenshot (Python)

Source: https://www.screenshotapi.net/docs/scrollingScreenshot

This Python script shows how to obtain a scrolling screenshot using the ScreenshotAPI. It uses the `requests` library to send a GET request to the API. The response text, which contains the screenshot information, is then printed to the console. Make sure to install the `requests` library (`pip install requests`).

```python
import requests

url = "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&output=json&file_type=gif&wait_for_event=load&scrolling_screenshot=true"
payload = {}
headers = {}

response = requests.request("GET", url, headers, data=payload)
print(response.text)
```

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

### Generate Scrolling Screenshot (Node.js)

Source: https://www.screenshotapi.net/docs/scrollingScreenshot

This Node.js snippet demonstrates how to capture a scrolling screenshot of a web page using the ScreenshotAPI. It utilizes the axios library to make a GET request with specific parameters for URL, output format, and scrolling screenshot enablement. Ensure you have axios installed (`npm install axios`).

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

let config = {
	method: "get",
	maxBodyLength: Infinity,
	url: "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&output=json&file_type=gif&wait_for_event=load&scrolling_screenshot=true",
	headers: { }
};
axios.request(config).then((response) => {
	console.log(JSON.stringify(response.data));
}.catch((error) => {
	console.log(error);
});
```

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

### Capture Screenshot with Proxy (Go)

Source: https://www.screenshotapi.net/docs/proxy

This Go program illustrates how to take a screenshot using ScreenshotAPI with a proxy. It constructs an HTTP GET request to the API, including the proxy configuration in the URL. The response body is read and printed to the console.

```go
package main

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

func main() {
	url := "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&output=image&file_type=png&wait_for_event=load&proxy=http%3A%2F%2Fxo%3Allksoigsgrewvc%40157.230.191.197%3A3128"
	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 := io.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}
```

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

### Force Fresh Screenshot with fresh=true

Source: https://www.screenshotapi.net/docs/renderScreenshot

This PHP example demonstrates how to request a fresh screenshot, bypassing the cache, by setting `fresh=true`. It utilizes the `http` client library to send the GET request to the ScreenshotAPI.

```php
<?php
	$client = new http.Client;
	$request = new http.Client.Request;
	$request->setRequestUrl("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&fresh=true&[OPTIONS]");
	$request->setRequestMethod("GET");
	$request->setOptions(array());

	$client->enqueue($request)->send();
	$response = $client->getResponse();
	echo $response->getBody();
?>

```

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

### Capture Screenshot with Java

Source: https://www.screenshotapi.net/docs/getStarted

This Java code snippet demonstrates how to capture a screenshot using the Screenshot API. It constructs the API request URL, opens a connection to it, and then transfers the input stream (image data) to an output stream, saving it as 'screenshot.png'. Basic exception handling is included.

```java
package main;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLEncoder;

public class Main{

	public static void main(String[] args) {
		try {
			// @param {String} $token - String containing your API Key 
			// @param {String} $url - Encoded URI string container the URI you're targeting 
			// @param {String} $output - String specifying the output format, 'image' or 'json'
			// @param {String} file_type - String specifying the output type
			String token = "Your API Key";
			String url = URLEncoder.encode("https://google.com");
			String output = "image";
			String file_type = "png";

			// Construct the query params and URL
			String query = "https://shot.screenshotapi.net/screenshot";
 			query += String.format("?token=%s&url=%s&output=%s&file_type=%s",
				token, url, output, file_type);
			URL apiUrl = new URL(query);

			// Call the API and save the screenshot
			InputStream inputStream = apiUrl.openStream();
			OutputStream outputStream = new FileOutputStream("./screenshot.png");
			inputStream.transferTo(outputStream);

			inputStream.close();
			outputStream.close();
 		} catch(Exception ex) {
			ex.printStackTrace();
 		}
 	}
}
```

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

### Generate Scrolling Screenshot (Java)

Source: https://www.screenshotapi.net/docs/scrollingScreenshot

This Java snippet illustrates how to capture a scrolling screenshot using ScreenshotAPI with OkHttpClient. It constructs a GET request to the API endpoint and executes it to retrieve the response. This example assumes you have the OkHttpClient library added to your project dependencies.

```java
OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder().url("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&output=json&file_type=gif&wait_for_event=load&scrolling_screenshot=true"
	.method("GET", body)
	.build();
Response response = client.newCall(request)
	.execute();
```
Tokens:
Raw