# Parameter

Die API hat die folgenden Parameter: Nur das Token und die URL sind obligatorisch, der Rest ist optional.

# Zeichen

• Erforderlich
• Höhe string

Dieser Parameter ist für alle Anrufe erforderlich

Dies ist Ihr Authentifizierungstoken. Sie haben zwei Token: einen für normale Anfragen und einen für JavaScript-Anfragen.

Verwenden Sie das JavaScript-Token, wenn der Inhalt, den Sie crawlen müssen, über JavaScript generiert wird, entweder weil es sich um eine mit JavaScript erstellte Seite handelt (React, Angular usw.) oder weil der Inhalt dynamisch im Browser generiert wird.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))

# URL

• Erforderlich
• Höhe string

Dieser Parameter ist für alle Anrufe erforderlich

Sie benötigen eine URL zum Crawlen. Stellen Sie sicher, dass sie mit http oder https beginnt und dass ist vollständig kodiert.

Beispielsweise in der folgenden URL: https://github.com/crawlbase?tab=repositories Die URL sollte beim Aufruf der API wie folgt codiert werden: https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))

# Format

• Nein
• Höhe string

Gibt das Antwortformat an, entweder json or html. Der Standardwert ist html.

Wenn Format html Verwendet wird, sendet Crawlbase Ihnen die Antwortparameter in den Headern zurück (siehe [HTML-Antwort]/de/crawling-api/response/#html-response) unten).

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories&format=json"

require 'net/http'
require 'json'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  format: 'json',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
json = JSON.parse(res)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Response JSON Body: \#{res.body}"
puts "Response Body: \#{json['body']}"
puts "Response Original Status: \#{json['original_status']}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&format=json&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => {
    const json = JSON.parse(body);
    console.log(json.original_status);
    console.log(json.body);
  });
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&format=json&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

$json = json_decode($response);
var_dump($json['body']);
var_dump($json['original_status']);

from urllib2 import urlopen
from urllib import quote_plus
import json

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&format=json&url=' + url)

parsed_json = json.loads(handler.read())
print parsed_json['original_status']
print parsed_json['body']

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&format=json&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  var parsedJson map[string]interface{}
  json.Unmarshal(body, &parsedJson)

  fmt.Println("response: ", parsedJson["original_status"].(float64), parsedJson["body"].(string))
}

# Ziemlich

• Nein
• Höhe boolean

Wenn Sie erwarten eine json Antwort können Sie die Lesbarkeit optimieren, indem Sie &pretty=true.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories&format=json&pretty=true"

require 'net/http'
require 'json'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  format: 'json',
  pretty: true,
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
json = JSON.parse(res)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Response JSON Body: \#{res.body}"
puts "Response Body: \#{json['body']}"
puts "Response Original Status: \#{json['original_status']}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&format=json&pretty=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => {
    const json = JSON.parse(body);
    console.log(json.original_status);
    console.log(json.body);
  });
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&format=json&pretty=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

$json = json_decode($response);
var_dump($json['body']);
var_dump($json['original_status']);

from urllib2 import urlopen
from urllib import quote_plus
import json

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&format=json&pretty=true&url=' + url)

parsed_json = json.loads(handler.read())
print parsed_json['original_status']
print parsed_json['body']

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&format=json&pretty=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  var parsedJson map[string]interface{}
  json.Unmarshal(body, &parsedJson)

  fmt.Println("response: ", parsedJson["original_status"].(float64), parsedJson["body"].(string))
}

# user_agent

• Nein
• Höhe string

Wenn Sie die Anfrage mit einem benutzerdefinierten Benutzeragenten stellen möchten, können Sie ihn hier übergeben und unser Server leiten ihn über die angeforderte URL weiter.

Wir empfehlen zu NICHT Verwenden Sie diese Parameter und überlassen Sie die Handhabung unserer künstlichen Intelligenz.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&user_agent=Mozilla%2F5.0+%28Macintosh%3B+Intel+Mac+OS+X+10_12_5%29+AppleWebKit%2F603.2.4+%28KHTML%2C+like+Gecko%29+Version%2F10.1.1+Safari%2F603.2.4&url=https%3A%2F%2Fpostman-echo.com%2Fheaders"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  user_agent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.1 Safari/605.1.15',
  url: 'https://postman-echo.com/headers'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://postman-echo.com/headers');
const userAgent = encodeURIComponent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.1 Safari/605.1.15');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&user_agent=' + userAgent + '&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://postman-echo.com/headers');
$userAgent = urlencode('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.1 Safari/605.1.15');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&user_agent=' . $userAgent . '&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://postman-echo.com/headers')
user_agent = quote_plus('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.1 Safari/605.1.15')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&user_agent=' + user_agent + '&url=' + url)

print handler.read()

package main

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

func main() {
  urlString := url.QueryEscape("https://postman-echo.com/headers")
  userAgent := url.QueryEscape("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.1 Safari/605.1.15")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&user_agent=" + userAgent + "&url=" + urlString)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Seite_warten

• Nein
• Höhe number

Wenn Sie das JavaScript-Token verwenden, können Sie optional Folgendes übergeben: page_wait Parameter zum Warten einer bestimmten Zeitspanne Millisekunden Bevor der Browser den entsprechenden HTML-Code erfasst.

Dies ist in Fällen nützlich, in denen das Rendern der Seite einige Sekunden dauert oder vor der Erfassung des HTML etwas Ajax geladen werden muss.

curl "https://api.crawlbase.com/?token=_JS_TOKEN_&page_wait=1000&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_JS_TOKEN_',
  page_wait: '1000',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_JS_TOKEN_&page_wait=1000&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_JS_TOKEN_&page_wait=1000&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_JS_TOKEN_&page_wait=1000&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_JS_TOKEN_&page_wait=1000&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# ajax_wait

• Nein
• Höhe boolean

Wenn Sie das JavaScript-Token verwenden, können Sie optional Folgendes übergeben: ajax_wait Parameter, um auf den Abschluss der Ajax-Anfragen zu warten, bevor die HTML-Antwort abgerufen wird.

curl "https://api.crawlbase.com/?token=_JS_TOKEN_&ajax_wait=true&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_JS_TOKEN_',
  ajax_wait: true,
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_JS_TOKEN_&ajax_wait=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_JS_TOKEN_&ajax_wait=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_JS_TOKEN_&ajax_wait=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_JS_TOKEN_&ajax_wait=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# CSS-Klickselektor

• Nein
• Höhe string

# Einzelner CSS-Selektor

Wenn Sie das JavaScript-Token verwenden, können Sie das optional tun css_click_selector Parameter, um auf ein Element auf der Seite zu klicken, bevor der Browser den HTML-Code erfasst.

Dieser Parameter akzeptiert einen vollständig angegebenen und gültigen CSS-Selektor. Sie können beispielsweise einen ID-Selektor wie #some-button, ein Klassenselektor wie .some-other-buttonoder ein Attributselektor wie [data-tab-item="tab1"]. Um Fehler zu vermeiden, muss sichergestellt werden, dass der CSS-Selektor richtig codiert ist.

Bitte beachten Sie, dass die Anfrage fehlschlägt, wenn der Selektor nicht auf der Seite gefunden wird. pc_status 595Um eine Antwort zu erhalten, auch wenn ein Selektor nicht gefunden wird, können Sie einen universellen Selektor anhängen, wie body, als Fallback. Beispiel: #some-button,body.

# Mehrere CSS-Selektoren

Um Szenarien zu berücksichtigen, in denen mehrere Elemente nacheinander angeklickt werden müssen, bevor der Seiteninhalt erfasst wird, css_click_selector Parameter können nun mehrere CSS-Selektoren akzeptieren. Trennen Sie die einzelnen Selektoren durch ein Pipe-Zeichen (|)-Zeichen. Stellen Sie sicher, dass der gesamte Wert, einschließlich Trennzeichen, URL-codiert ist, um Analyseprobleme zu vermeiden.

Angenommen, Sie möchten auf eine Schaltfläche mit der ID klicken start-button und dann ein Link mit der Klasse next-page-link. Sie würden Ihre css_click_selector Parameter wie folgt:

• Ursprüngliche Selektoren: #start-button|.next-page-link
• URL-kodiert: %23start-button%7C.next-page-link

Hängen Sie diese Parameter an Ihre API-Anfrage an, um sicherzustellen, dass beide Elemente in der angegebenen Reihenfolge angeklickt werden.

Bitte stellen Sie sicher, dass alle angegebenen Selektoren gültig und auf der Seite vorhanden sind, um Fehler zu vermeiden. Wenn ein Selektor nicht gefunden wird, folgt die Anfrage der oben angegebenen Fehlerbehandlung und schlägt fehl mit pc_status 595 Es sei denn, ein Fallback-Selektor ist enthalten.

curl "https://api.crawlbase.com/?token=_JS_TOKEN_&css_click_selector=%5Bdata-tab-item%3D%22overview%22%5D&page_wait=1000&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_JS_TOKEN_',
  page_wait: '1000',
  css_click_selector: '[data-tab-item="overview"]',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_JS_TOKEN_&css_click_selector=%5Bdata-tab-item%3D%22overview%22%5D&page_wait=1000&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_JS_TOKEN_&css_click_selector=%5Bdata-tab-item%3D%22overview%22%5D&page_wait=1000&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_JS_TOKEN_&css_click_selector=%5Bdata-tab-item%3D%22overview%22%5D&page_wait=1000&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_JS_TOKEN_&css_click_selector=%5Bdata-tab-item%3D%22overview%22%5D&page_wait=1000&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Gerät

• Nein
• Höhe string

Wenn Sie optional keinen User_Agent angeben möchten, aber die Anfragen von einem bestimmten Gerät erhalten möchten, können Sie diesen Parameter verwenden.

Es stehen zwei Optionen zur Verfügung: desktop und mobile.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&device=mobile&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  device: 'mobile',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&device=mobile&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&device=mobile&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&device=mobile&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&device=mobile&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# get_cookies

• Nein
• Höhe boolean

Wenn Sie optional die Cookies abrufen möchten, können Sie die ursprüngliche Website auf die Antwort setzen &get_cookies=true Parameter

Die Cookies werden im Header (oder in der JSON-Antwort, wenn Sie verwenden) zurückgegeben. &format=json) wie original_set_cookie.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&get_cookies=true&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  get_cookies: true,
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&get_cookies=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&get_cookies=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&get_cookies=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&get_cookies=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# get_headers

• Nein
• Höhe boolean

Wenn Sie optional den Header abrufen möchten, kann die ursprüngliche Website in der Antwort festlegt werden &get_headers=true Parameter

Die Header werden in der Antwort zurückgegeben original_header_name standardmäßig. Wenn &format=json Übergeben wird, wird der Header zurückgegeben als original_headers.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&get_headers=true&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  get_headers: true,
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&get_headers=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&get_headers=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&get_headers=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&get_headers=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Anforderungenheader

• Nein
• Höhe string

Wenn Sie optionale Anforderungsheader an die ursprüngliche Website senden müssen, können Sie den &request_headers=EncodedRequestHeaders Parameter

Beispiele für Anforderungsheader: Akzeptieren Sie die Sprache: en-GB | Akzeptieren Sie die Kodierung: gzip

Beispiel codiert: &request_headers=accept-language%3Aen-GB%7Caccept-encoding%3Agzip

Bitte beachten Sie, dass nicht alle Anforderungsheader von der API zugelassen werden. Wir empfehlen Ihnen, den gesendeten Header mit dieser Test-URL zu testen: https://postman-echo.com/headers

Wenn Sie zusätzliche Header senden müssen, die von der API nicht zugelassen werden, teilen Sie uns bitte die Header-Namen mit und wir autorisieren sie für Ihr Token.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&request_headers=accept-language%3Aen-GB%7Caccept-encoding%3Agzip&url=https%3A%2F%2Fpostman-echo.com%2Fheaders"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  request_headers: 'accept-language:en-GB|accept-encoding:gzip',
  url: 'https://postman-echo.com/headers'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://postman-echo.com/headers');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&request_headers=accept-language%3Aen-GB%7Caccept-encoding%3Agzip&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://postman-echo.com/headers');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&request_headers=accept-language%3Aen-GB%7Caccept-encoding%3Agzip&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://postman-echo.com/headers')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&request_headers=accept-language%3Aen-GB%7Caccept-encoding%3Agzip&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://postman-echo.com/headers")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&request_headers=accept-language%3Aen-GB%7Caccept-encoding%3Agzip&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Cookies setzen

• Nein
• Höhe string

Wenn Sie Cookies an die ursprüngliche Website senden müssen, können Sie optional sterben &cookies=EncodedCookies Parameter

Beispiel-Cookies: key1=value1; key2=value2; key3=value3

Beispiel codiert: &cookies=key1%3Dvalue1%3B%20key2%3Dvalue2%3B%20key3%3Dvalue3

Wir empfehlen Ihnen, die gesendeten Cookies mit dieser Test-URL zu testen: https://postman-echo.com/cookies

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&cookies=key1%3Dvalue1%3B%20key2%3Dvalue2%3B%20key3%3Dvalue3&url=https%3A%2F%2Fpostman-echo.com%2Fcookies"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  cookies: 'key1=value1; key2=value2; key3=value3',
  url: 'https://postman-echo.com/cookies'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://postman-echo.com/cookies');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&cookies=key1%3Dvalue1%3B%20key2%3Dvalue2%3B%20key3%3Dvalue3&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://postman-echo.com/cookies');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&cookies=key1%3Dvalue1%3B%20key2%3Dvalue2%3B%20key3%3Dvalue3&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://postman-echo.com/cookies')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&cookies=key1%3Dvalue1%3B%20key2%3Dvalue2%3B%20key3%3Dvalue3&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://postman-echo.com/cookies")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&cookies=key1%3Dvalue1%3B%20key2%3Dvalue2%3B%20key3%3Dvalue3&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# cookies_sitzung

• Nein
• Höhe string

Wenn Sie die Cookies, die bei jeder Anfrage zurückkommen, an alle nachfolgenden Aufrufe senden müssen, können Sie den &cookies_session= Parameter

Eine &cookies_session= Parameter kann ein beliebiger Wert sein. Senden Sie einfach einen Wert, um eine neue Cookies-Sitzung zu erstellen (so können Sie die zurückgegebenen Cookies aus den nachfolgenden Aufrufen mit diesem Cookies-Sitzungswert an die nächste neue API-Aufrufe senden). Der Wert kann maximal 32 Zeichen lang sein und Sitzungen laufen 300 Sekunden nach dem letzten API-Aufruf ab.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&cookies_session=1234abcd&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  cookies_session: '1234abcd',
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&cookies_session=1234abcd&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&cookies_session=1234abcd&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&cookies_session=1234abcd&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&cookies_session=1234abcd&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Bildschirmfoto

• Nein
• Höhe boolean

Wenn Sie das verwenden JavaScript-TokenSie können optional weitergeben &screenshot=true Parameter, um einen Screenshot im JPEG Format der gesamten gecrawlten Seite.

Crawlbase sendet Ihnen die screenshot_url in den Antwortheadern (oder in der JSON-Antwort, wenn Sie &format=json). Der screenshot_url läuft in einer Stunde ab.

Hinweis: Bei der screenshot=true Parameter können Sie die Screenshot-Ausgabe mit diesen zusätzlichen Parametern anpassen:

• mode: Einstellen viewport Um nur den Ansichtsbereich statt der gesamten Seite zu erfassen. Standard ist fullpage.
• width: Maximale Breite in Pixeln angeben (funktioniert nur mit mode=viewport). Standardmäßig ist die Bildschirmbreite eingestellt.
• height: Maximale Höhe in Pixeln angeben (funktioniert nur mit mode=viewport). Standardmäßig ist die Bildschirmhöhe eingestellt.

Beispiel: &screenshot=true&mode=viewport&width=1200&height=800

curl "https://api.crawlbase.com/?token=_JS_TOKEN_&screenshot=true&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_JS_TOKEN_',
  screenshot: true,
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"
puts "Response Screenshot URL: \#{res['screenshot_url']}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_JS_TOKEN_&screenshot=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_JS_TOKEN_&screenshot=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_JS_TOKEN_&screenshot=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_JS_TOKEN_&screenshot=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Kaufen Sie ein

• Nein
• Höhe boolean

Optional weitergeben &store=true Parameter zum Speichern einer Kopie der API-Antwort im Crawlbase Cloud-Speicher (neues Fenster öffnen) (öffnet neues Fenster).

Crawlbase sendet Ihnen die storage_url in den Antwortheadern (oder in der JSON-Antwort, wenn Sie &format=json).

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&store=true&url=https%3A%2F%2Fgithub.com%2Fcrawlbase%3Ftab%3Drepositories"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  store: true,
  url: 'https://github.com/crawlbase?tab=repositories'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"
puts "Response Storage URL: \#{res['storage_url']}"

const https = require('https');

const url = encodeURIComponent('https://github.com/crawlbase?tab=repositories');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&store=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://github.com/crawlbase?tab=repositories');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&store=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://github.com/crawlbase?tab=repositories')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&store=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://github.com/crawlbase?tab=repositories")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&store=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Schaber

• Nein
• Höhe string

Es gibt die Informationen zurück, die gemäß dem angegebenen Scraper analysiert wurden. Überprüfen Sie, ob Sie sterben Liste aller verfügbaren Daten-Scraper (öffnet neues Fenster) (öffnet neues Fenster) Listen Sie alle verfügbaren Daten-Scraper auf, um zu sehen, welche Sie wählen sollten.

Die Antwort wird als JSON zurückgegeben.

Bitte beachte: Scraper ist ein optionaler Parameter. Wenn Sie ihn nicht verwenden, erhalten Sie das vollständige HTML der Seite zurück, sodass Sie es frei scrapen können.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&scraper=amazon-product-details&url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB0B7CBZZ16"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  scraper: 'amazon-product-details',
  url: 'https://www.amazon.com/dp/B0B7CBZZ16'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://www.amazon.com/dp/B0B7CBZZ16');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&scraper=amazon-product-details&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://www.amazon.com/dp/B0B7CBZZ16');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&scraper=amazon-product-details&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://www.amazon.com/dp/B0B7CBZZ16')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&scraper=amazon-product-details&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://www.amazon.com/dp/B0B7CBZZ16")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&scraper=amazon-product-details&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# async

• Nein
• Höhe boolean
• Derzeit wird mit diesem Parameter nur LinkedIn.com unterstützt. Sprechen Sie uns an, wenn Sie andere Domänen im asynchronen Modus benötigen.

Optional weitergeben &async=true Parameter, um die gewünschte URL asynchron zu crawlen. Crawlbase speichert die entsprechende Seite im Crawlbase Cloud-Speicher (neues Fenster öffnen) (öffnet neues Fenster).

Als Ergebnis eines Anrufs mit async=true, Crawlbase sendet Ihnen die Anforderungskennung zurück rid in der JSON-Antwort. Sie müssen die RID speichern, um das Dokument aus dem Speicher abzurufen. Mit der RID können Sie dann sterben Cloud Storage-API (öffnet neues Fenster) (öffnet neues Fenster) um die entsprechende Seite abzurufen.

Sie können die Verwendung async=true Parameter in Kombination mit anderen API-Parametern wie zum Beispiel &async=true&autoparse=true.

Beispiel einer Anfrage mit async=true Anruf:

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&async=true&url=https%3A%2F%2Fwww.linkedin.com%2Fcompany%2Fcrawlbase"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  async: true,
  url: 'https://www.linkedin.com/company/crawlbase'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://www.linkedin.com/company/crawlbase');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&async=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://www.linkedin.com/company/crawlbase');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&async=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://www.linkedin.com/company/crawlbase')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&async=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://www.linkedin.com/company/crawlbase")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&async=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

Beispiel einer Antwort mit async=true Anruf:

{ "rid": "1e92e8bff32c31c2728714d4" }

# automatische Analyse

• Nein
• Höhe boolean

Wenn Sie optional die Scraped-Daten der von Ihnen angeforderten Seite abrufen möchten, können Sie Folgendes weitergeben: &autoparse=true Parameter

Die Antwort wird als JSON zurückgegeben. Die Struktur der Antwort variiert je nach der von Ihnen gesendeten URL.

Bitte beachte: &autoparse=true ist ein optionaler Parameter. Wenn Sie ihn nicht verwenden, erhalten Sie das vollständige HTML der Seite zurück, sodass Sie es frei scrapen können.

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&autoparse=true&url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB0B7CBZZ16"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  autoparse: 'true',
  url: 'https://www.amazon.com/dp/B0B7CBZZ16'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://www.amazon.com/dp/B0B7CBZZ16');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&autoparse=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://www.amazon.com/dp/B0B7CBZZ16');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&autoparse=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://www.amazon.com/dp/B0B7CBZZ16')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&autoparse=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://www.amazon.com/dp/B0B7CBZZ16")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&autoparse=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# Land

• Nein
• Höhe string

Wenn Sie möchten, dass Ihre Anfragen aus einem bestimmten Land geolokalisiert werden, können Sie sterben &country= Parameter, wie &country=US (zweistelliger Ländercode).

Bitte beachten Sie, dass die Angabe eines Landes die Anzahl der erfolgreichen Anfragen verringern kann. Verwenden Sie es daher mit Bedacht und nur, wenn Geolokalisierungs-Crawls erforderlich sind.

Beachten Sie auch, dass einige Websites wie Amazon über verschiedene spezielle Proxys weitergeleitet werden und alle Länder zugelassen werden, unabhängig davon, ob sie auf der Liste stehen oder nicht.

Sie haben Zugriff auf folgende Länder

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&country=US&url=https%3A%2F%2Fpostman-echo.com%2Fip"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  country: 'US',
  url: 'https://postman-echo.com/ip'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://postman-echo.com/ip');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&country=US&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://postman-echo.com/ip');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&country=US&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://postman-echo.com/ip')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&country=US&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://postman-echo.com/ip")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&country=US&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# tor_netzwerk

• Nein
• Höhe boolean

Wenn Sie Onion-Websites über das Tor-Netzwerk crawlen möchten, können Sie sterben &tor_network=true Parameter

curl "https://api.crawlbase.com/?token=_USER_TOKEN_&tor_network=true&url=https%3A%2F%2Fwww.facebookcorewwwi.onion%2F"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_USER_TOKEN_',
  tor_network: 'true',
  url: 'https://www.facebookcorewwwi.onion/'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://www.facebookcorewwwi.onion/');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_USER_TOKEN_&tor_network=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://www.facebookcorewwwi.onion/');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_USER_TOKEN_&tor_network=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://www.facebookcorewwwi.onion/')

handler = urlopen('https://api.crawlbase.com/?token=_USER_TOKEN_&tor_network=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://www.facebookcorewwwi.onion/")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_USER_TOKEN_&tor_network=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}

# blattern

• Nein
• Höhe boolean

Wenn Sie das verwenden JavaScript-TokenSie können optional weitergeben &scroll=true Laut der API wird dabei standardmäßig ein Scrollintervall von 10 Sekunden eingehalten.

Wenn Sie länger als 10 Sekunden scrollen möchten, senden Sie bitte die Nachricht &scroll=true&scroll_interval=20. Diese Parameter weisen den Browser an, nach dem Laden der Seite 20 Sekunden lang zu scrollen. Das maximale Scrollintervall beträgt 60 Sekunden. Nach 60 Sekunden Scrollen erfasst das System die Daten und bringt sie zu Ihnen zurück.

Das Standard-Scrollintervall beträgt 10 Sekunden. Alle 5 Sekunden zusätzliches erfolgreiches Scrollen zählen als JS-Anfrage an die Crawling-API. Nehmen wir auch an, Sie senden ein Scrollintervall von 20. Unser System versucht, die Seite maximal 20 Sekunden lang zu scrollen. Wenn es nur 10 Sekunden lang scrollen konnte, werden nur 2 zusätzliche Anfragen verbraucht, statt 4.

Hinweis: Bitte achten Sie darauf, dass Ihre Verbindung bis zu 90 Sekunden lang offen bleibt, wenn Sie 60 Sekunden lang scrollen möchten.

curl "https://api.crawlbase.com/?token=_JS_TOKEN_&scroll=true&url=https%3A%2F%2Fwww.reddit.com%2Fsearch%2F%3Fq%3Dcrawlbase"

require 'net/http'

uri = URI('https://api.crawlbase.com')
uri.query = URI.encode_www_form({
  token: '_JS_TOKEN_',
  scroll: true,
  url: 'https://www.reddit.com/search/?q=crawlbase'})

res = Net::HTTP.get_response(uri)
puts "Response HTTP Status Code: \#{res.code}"
puts "Response HTTP Header Original Status: \#{res['original_status']}"
puts "Response HTTP Response Body: \#{res.body}"

const https = require('https');

const url = encodeURIComponent('https://www.reddit.com/search/?q=crawlbase');
const options = {
  hostname: 'api.crawlbase.com',
  path: '/?token=_JS_TOKEN_&scroll=true&url=' + url
};

https.request(options, (response) => {
  let body = '';
  response.on('data', chunk => body += chunk).on('end', () => console.log(body));
}).end();

$url = urlencode('https://www.reddit.com/search/?q=crawlbase');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.crawlbase.com/?token=_JS_TOKEN_&scroll=true&url=' . $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

var_dump($response);

from urllib2 import urlopen
from urllib import quote_plus

url = quote_plus('https://www.reddit.com/search/?q=crawlbase')

handler = urlopen('https://api.crawlbase.com/?token=_JS_TOKEN_&scroll=true&url=' + url)

print handler.read()

package main

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

func main() {
  url := url.QueryEscape("https://www.reddit.com/search/?q=crawlbase")
  resp, _ := http.Get("https://api.crawlbase.com/?token=_JS_TOKEN_&scroll=true&url=" + url)

  defer resp.Body.Close()
  body, _ := ioutil.ReadAll(resp.Body)

  fmt.Println("response Body: ", string(body))
}