Controlling Page Rendering

Rendering options

The parameter render_options includes several configuration options that allow users to fine-tune how Nimble renders webpages. These options include:

Parameter	Required	Description
include_iframes	No (default = false)	Boolean - Instructs Nimble APIs to render or not to render iframes.
timeout	No (default = 30000) Maximum: 60000	Integer (ms) - Defines how long Nimble APIs will wait for a page to finish loading.
render_type	No (default = load)	Enum - Defines the state that Nimble APIs will consider a page as fully loaded.
blocked_domains	No (default = null)	Prevent loading of resources from certain domains.

Render Type and controlling what is a "fully loaded" page

Because many webpages load additional content after the initial page has finished loading (such as single-page applications), deciding exactly when a webpage has finished loading is often ambiguous. To aid with this, Nimble APIs supports several options:

• load - Nimble will consider a page ready after the standard page load event is fired.

• domready - Nimble will consider a page ready when the DOMContentLoaded event is fired.

• idle2 - Nimble will consider a page ready when there are 2 or fewer network connections made during the last 500ms.

• idle0 - Nimble will consider a page ready when no new network connections are made during the last 500ms.

In the below example, render_type and timeout are combined to illustrate how to simulatenously use rendering options:

cURL

curl -X POST 'https://api.webit.live/api/v1/realtime/web' \
--header 'Authorization: Basic <credential string>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "url": "https://www.example.com",
    "method": "GET",
    "parse": true,
    "render": true,
    "render_options": {
        "include_iframes": true,
        "render_type": "idle0",
	"timeout": 35000
    }
}'

Python

import requests

url = 'https://api.webit.live/api/v1/realtime/web'
headers = {
    'Authorization': 'Basic <credential string>',
    'Content-Type': 'application/json'
}
data = {
    "url": "https://www.example.com",
    "method": "GET",
    "parse": True,
    "render": True,
    "render_options": {
        "include_iframes": True,
        "render_type": "idle0",
        "timeout": 35000
    }
}

response = requests.post(url, headers=headers, json=data)

print(response.status_code)
print(response.json())

Node.js

const axios = require('axios');

const url = 'https://api.webit.live/api/v1/realtime/web';
const headers = {
  'Authorization': 'Basic <credential string>',
  'Content-Type': 'application/json'
};
const data = {
  "url": "https://www.example.com",
  "method": "GET",
  "parse": true,
  "render": true,
  "render_options": {
    "include_iframes": true,
    "render_type": "idle0",
    "timeout": 35000
  }
};

axios.post(url, data, { headers })
  .then(response => {
    console.log(response.status);
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

Go

package main

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

func main() {
	url := "https://api.webit.live/api/v1/realtime/web"
	payload := []byte(`{
		"url": "https://www.example.com",
		"method": "GET",
		"parse": true,
		"render": true,
		"render_options": {
			"include_iframes": true,
			"render_type": "idle0",
			"timeout": 35000
		}
	}`)
	headers := map[string]string{
		"Authorization":  "Basic <credential string>",
		"Content-Type":   "application/json",
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	if err != nil {
		fmt.Println(err)
		return
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

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

	fmt.Println(resp.StatusCode)
	// Read the response body if needed
	// body, err := ioutil.ReadAll(resp.Body)
	// fmt.Println(string(body))
}

Controlling resource loading within a webpage

Webpages typically load resources from many external domains, including iframes, images, javascript files, and other resources. In some cases, it may be beneficial to restrict non-essential resources in order to speed up the loading of a page, save bandwidth, and more.

Nimble provides two rendering options that help control what parts of a page are loaded, called include_iframes and blocked_domains.

• include_iframes - controls whether iframes within the target page are loaded or not.

• blocked_domains - a list of domains from which external resources are not to be loaded.

In the below example, we set include_iframes to "true" to allow iframes to be loaded, and add "example2.com" and "example3.com" toblocked_domains to prevent resources from those domains being loaded:

cURL

curl -X POST 'https://api.webit.live/api/v1/realtime/web' \
--header 'Authorization: Basic <credential string>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "url": "https://www.example.com",
    "method": "GET",
    "parse": true,
    "render": true,
    "render_options": {
        "include_iframes": true,
        "blocked_domains": ["example2.com", "example3.com"]
    }
}'

Python

import requests

url = 'https://api.webit.live/api/v1/realtime/web'
headers = {
    'Authorization': 'Basic <credential string>',
    'Content-Type': 'application/json'
}
data = {
    "url": "https://www.example.com",
    "method": "GET",
    "parse": True,
    "render": True,
    "render_options": {
        "include_iframes": True,
        "blocked_domains": ["example2.com", "example3.com"]
    }
}

response = requests.post(url, headers=headers, json=data)

print(response.status_code)
print(response.json())

Node.js

const axios = require('axios');

const url = 'https://api.webit.live/api/v1/realtime/web';
const headers = {
  'Authorization': 'Basic <credential string>',
  'Content-Type': 'application/json'
};
const data = {
  "url": "https://www.example.com",
  "method": "GET",
  "parse": true,
  "render": true,
  "render_options": {
    "include_iframes": true,
    "blocked_domains": ["example2.com", "example3.com"]
  }
};

axios.post(url, data, { headers })
  .then(response => {
    console.log(response.status);
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

Go

package main

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

func main() {
	url := "https://api.webit.live/api/v1/realtime/web"
	payload := []byte(`{
		"url": "https://www.example.com",
		"method": "GET",
		"parse": true,
		"render": true,
		"render_options": {
			"include_iframes": true,
			"blocked_domains": ["example2.com", "example3.com"]
		}
	}`)
	headers := map[string]string{
		"Authorization":  "Basic <credential string>",
		"Content-Type":   "application/json",
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	if err != nil {
		fmt.Println(err)
		return
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

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

	fmt.Println(resp.StatusCode)
	// Read the response body if needed
	// body, err := ioutil.ReadAll(resp.Body)
	// fmt.Println(string(body))
}