Valeur nette
cURL Node.js Python Ruby PHP

Vue d'ensemble

Introduction

Il s'agit de la documentation officielle du API REST Geekflare.

Ces API offrent de nombreuses fonctionnalités pour des méthodes de test et de surveillance importantes pour les sites Web. Par exemple, les performances du site Web, la sécurité, le DNS et le score SEO sont quelques-unes des fonctionnalités offertes par ces API.

Getting started

Démarrer avec l'API Geekflare est très simple. Vous devez vous inscrire (aucune carte de crédit requise) pour accéder au niveau gratuit de Geekflare.

Obtenez votre clé API

API type

L'API Geekflare est un API REST. Cela signifie qu'il fonctionne sur HTTP et accepte et renvoie les données dans le JSON le format.

Rate (usage) limits

L'API Geekflare permet un taux d'appel de 25 appels API par seconde dans le cadre d'un plan premium pour chaque client ayant un jeton valide.

Proxy county

Beaucoup de API Geekflare demande d'assistance via proxy. Si vous avez besoin d'utiliser cette fonctionnalité, le proxy à fournir en tant que proxyCountry paramètre.

Voici une liste des pays pris en charge :

Pays Code
États-Unis us
Royaume-Uni uk
France fr
Allemagne de
Canada ca
Inde in
Chine cn
Brasil br
Espagne es
Japon jp

Request

Authentification

Assurez-vous qu'il est présent dans votre valeur d'en-tête lorsque vous effectuez des appels d'API.

x-api-key YOUR-API-KEY

Il s'attend à ce que la clé d'accès à l'API soit présente dans un en-tête de requête appelé x-api-key.

URL de base

Pour tous les endpoints répertoriés dans cette documentation, l'URL de base est https://api.geekflare.com

Response

La réponse de l'API suit certains formats courants par souci de clarté et de cohérence. Selon l'état de la demande, les structures de réponse sont comme indiqué ci-dessous.

En cas de traitement réussi d'une requête, l'API renvoie une réponse au format suivant :

{
  "timestamp": 1610796547300,
  "apiStatus": "success",
  "apiCode": 200,
  "message": "An overview message.",
  "meta": {
    "url": "https://example.com"
  },
  "data": []
}

Lorsque la requête entrante n'a pas l'autorisation appropriée, la structure de réponse suivante est renvoyée :

{
  "message": "Forbidden"
}

Si vous avez un forfait gratuit et que vous essayez d'accéder à une API payante comme Port Scanner, cela renverra une erreur au format suivant :

{
  "timestamp": 1658254283953,
  "apiStatus": "failure",
  "apiCode": 403,
  "message": "You are not allowed to access. This is available to premium plan only."
}

Si un mauvais point de terminaison ou un mauvais type de requête (POST au lieu de GET, par exemple) est fourni, l'API renvoie une erreur au format suivant :

{
  "timestamp": 1657208461046,
  "apiStatus": "failure",
  "apiCode": 404,
  "message": "API not found.",
  "meta": {
    "method": "POST",
    "endpoint": "/helloworld"
  }
}

Points de terminaison d'API

L'API Geekflare comprend les points de terminaison suivants.

curl --location --request POST 'https://api.geekflare.com/brokenlink' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  proxyCountry: "us",
  followRedirect: true,
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/brokenlink",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/brokenlink"

payload = json.dumps({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": True
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/brokenlink")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}';
$request = new Request('POST', 'https://api.geekflare.com/brokenlink', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657109686205,
  "apiStatus": "success",
  "apiCode": 200,
  "message": "No broken links found.",
  "meta": {
    "url": "geekflare.com",
    "proxyCountry": "United States",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "wf0b7yrn05br8xtwple7ngj7hhxzvl2e"
    }
  },
  "data": [
    {
      "link": "https://geekflare.com/",
      "status": 200
    },
    {
      "link": "https://geekflare.com/articles",
      "status": 200
    }
  ]
}

L'API Broken Link Checker vérifie si la page Web contient des liens brisés.

Endpoint

/brokenlink

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
proxyCountry string Comté de procuration.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

DNS Records

curl --location --request POST 'https://api.geekflare.com/dnsrecord' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "types": ["A", "MX"]
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  types: ["A", "MX"],
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/dnsrecord",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/dnsrecord"

payload = json.dumps({
  "url": "geekflare.com",
  "types": [
    "A",
    "MX"
  ]
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/dnsrecord")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "types": [
    "A",
    "MX"
  ]
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "types": [
    "A",
    "MX"
  ]
}';
$request = new Request('POST', 'https://api.geekflare.com/dnsrecord', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657112689610,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "types": ["A", "MX"],
    "test": {
      "id": "zmkqoxxu075dwn4u61yoqhq2rwo0029m"
    }
  },
  "data": {
    "A": ["172.67.70.213", "104.26.11.88", "104.26.10.88"],
    "MX": [
      {
        "exchange": "alt3.aspmx.l.google.com",
        "priority": 10
      },
      {
        "exchange": "alt2.aspmx.l.google.com",
        "priority": 5
      },
      {
        "exchange": "alt1.aspmx.l.google.com",
        "priority": 5
      },
      {
        "exchange": "aspmx.l.google.com",
        "priority": 1
      }
    ]
  }
}

L'API DNS Records extrait et affiche les enregistrements DNS d'un nom de domaine donné.

Endpoint

/dnsrecord

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
types string[] Type(s) d'enregistrements DNS.

types Le paramètre prend en charge les chaînes suivantes.

Si vous ne fournissez pas le types paramètre, il affichera tous les enregistrements DNS.

Essayez-le vous-même

DNSSEC

curl --location --request POST 'https://api.geekflare.com/dnssec' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/dnssec",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/dnssec"

payload = json.dumps({
  "url": "geekflare.com"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/dnssec")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com"
}';
$request = new Request('POST', 'https://api.geekflare.com/dnssec', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657115589175,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "test": {
      "id": "x4akd0mw0947jdo4c9qqdfru2c1h7maq"
    }
  },
  "data": true
}

L'API DNSSEC teste si l'extension de sécurité est activée sur le domaine.

Endpoint

/dnssec

Paramètres

Nom Catégorie Description
url string L'URL à tester.

Essayez-le vous-même

HTTP Headers

curl --location --request POST 'https://api.geekflare.com/httpheader' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  proxyCountry: "us",
  followRedirect: true,
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/httpheader",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/httpheader"

payload = json.dumps({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": True
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/httpheader")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}';
$request = new Request('POST', 'https://api.geekflare.com/httpheader', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657118780944,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "proxyCountry": "United States",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "32ca8x3m08oiychu49gx9r3fvrw9t7f7"
    }
  },
  "data": [
    {
      "name": "date",
      "value": "Wed, 06 Jul 2022 14:46:20 GMT"
    },
    {
      "name": "content-type",
      "value": "text/html; charset=UTF-8"
    },
    {
      "name": "connection",
      "value": "close"
    }
  ]
}

L'API d'en-tête HTTP analyse les en-têtes de réponse d'un point de terminaison (ou site Web) donné et présente la sortie au format JSON. Cela peut être utile dans des activités telles que la surveillance, la collecte de données, etc.

Endpoint

/httpheader

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
proxyCountry string Comté de procuration.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

HTTP Protocol Support

curl --location --request POST 'https://api.geekflare.com/httpprotocol' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "followRedirect": true
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  followRedirect: true,
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/httpprotocol",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/httpprotocol"

payload = json.dumps({
  "url": "geekflare.com",
  "followRedirect": True
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/httpprotocol")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "followRedirect": true
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "followRedirect": true
}';
$request = new Request('POST', 'https://api.geekflare.com/httpprotocol', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657118991601,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "8b8beh8q03x5t82entwx9npfi1fxj39j"
    }
  },
  "data": {
    "http10": false,
    "http11": true,
    "http2": true,
    "http3": ["h3-29"]
  }
}

Alors que la spécification HTTP évolue constamment, les serveurs Web (faute de configuration ou de capacité) ne sont pas toujours en mesure de suivre le rythme. Cette API teste un point de terminaison HTTP et signale les versions HTTP actuellement prises en charge par ce point de terminaison.

Endpoint

/httpprotocol

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

Lighthouse

curl --location --request POST 'https://api.geekflare.com/lighthouse' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us",
  "followRedirect": true,
  "parameters": ["--only-categories=seo", "--output=csv"]
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  device: "desktop",
  proxyCountry: "us",
  followRedirect: true,
  parameters: ["--only-categories=seo", "--output=csv"],
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/lighthouse",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/lighthouse"

payload = json.dumps({
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us",
  "followRedirect": True,
  "parameters": [
    "--only-categories=seo",
    "--output=csv"
  ]
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/lighthouse")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us",
  "followRedirect": true,
  "parameters": [
    "--only-categories=seo",
    "--output=csv"
  ]
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us",
  "followRedirect": true,
  "parameters": [
    "--only-categories=seo",
    "--output=csv"
  ]
}';
$request = new Request('POST', 'https://api.geekflare.com/lighthouse', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657119087947,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "device": "desktop",
    "proxyCountry": "United States",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "3zniwkh5067adrro1llpqstdwbtei1va"
    }
  },
  "data": "https://api-assets.geekflare.com/tests/lighthouse/irlqk1082a5iohh56j1f480v.csv"
}

L'API Lighthouse permet d'accéder au projet Google Lighthouse en tant qu'API. Lighthouse est un outil d'audit pour les sites Web afin de les noter sur la performance, l'accessibilité, le référencement, etc., tout en fournissant des suggestions d'amélioration concrètes.

Endpoint

/lighthouse

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
device string L'appareil à utiliser.
parameters string[] Paramètres du phare.
proxyCountry string Comté de procuration.
followRedirect boolean Suivez la redirection.

device paramètre prend en charge desktop, mobile et tablet cordes. Si vous ne fournissez pas le paramètre de périphérique, desktop sera utilisé comme option par défaut.

Mode avancé

L'API Lighthouse s'exécute également en mode avancé, acceptant certains des paramètres de personnalisation reconnus par le moteur Lighthouse de Google :

Le --output paramètre contrôle le format de sortie. Il est réglé sur json par défaut, mais peut être html or csv également.

Pour utiliser ces paramètres, passez-les dans unparameters Tableau JSON dans le corps de l'entrée. Vous pouvez vous référer guide pour exécuter l'API Lighthouse en mode avancé.

Essayez-le vous-même

Load Time

curl --location --request POST 'https://api.geekflare.com/loadtime' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  proxyCountry: "us",
  followRedirect: true,
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/loadtime",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/loadtime"

payload = json.dumps({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": True
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/loadtime")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}';
$request = new Request('POST', 'https://api.geekflare.com/loadtime', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657119303041,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "proxyCountry": "United States",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "zbmzby8v07l4f4vp4po3h0x3c1qqr7bf"
    }
  },
  "data": {
    "dns": 10,
    "connect": 12,
    "tls": 9,
    "send": 19,
    "wait": 86,
    "total": 88
  }
}

L'API Load Time fournit le temps total (en millisecondes) nécessaire pour qu'une réponse HTTP se termine. Ceci est souvent utilisé pour mesurer les performances du site Web et comprend le temps nécessaire pour la recherche DNS, l'attente de la réponse du serveur, les données envoyées, les données reçues, etc.

Par défaut, la connexion se fait depuis des serveurs situés aux USA. Cependant, pour mesurer le temps de chargement depuis d'autres pays comme la France, le Royaume-Uni, la Chine, l'Inde, etc., vous pouvez utiliser un paramètre proxy mentionné ci-dessous.

Endpoint

/loadtime

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
proxyCountry string Comté de procuration.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

Meta Scraping

curl --location -g --request POST '{{base_url}}/public/metascraping' \
  --header 'Authorization: Bearer {{token}}' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
}
'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  device: "desktop",
  proxyCountry: "us",
});

var config = {
  method: "post",
  url: "{{base_url}}/public/metascraping",
  headers: {
    "Authorization": "Bearer {{token}}",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "{{base_url}}/public/metascraping"

payload = json.dumps({
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
})
headers = {
  'Authorization': 'Bearer {{token}}',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("{{base_url}}/public/metascraping")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer {{token}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
})

response = http.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'Authorization' => 'Bearer {{token}}',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
}';
$request = new Request('POST', '{{base_url}}/public/metascraping', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1663336951774,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "device": "desktop",
    "proxyCountry": "United States",
    "test": {
      "id": "ajfenqnl05l9dd8vh9zb2ffprr5g9k7o"
    }
  },
  "data": {
    "author": null,
    "date": "2022-06-07T14:04:26.000Z",
    "description": "Geekflare produces high-quality technology & finance articles, makes tools, and APIs to help businesses and people grow.",
    "image": "https://geekflare.com/wp-content/uploads/2019/06/Geekflare-social.png",
    "logo": "https://logo.clearbit.com/geekflare.com",
    "publisher": "Geekflare",
    "title": "Home",
    "url": "https://geekflare.com/",
    "lang": "en"
  }
}

L'API Meta Scraping vous permet d'extraire les métadonnées de n'importe quelle page Web. Vous pouvez extraire des données d'un site Web à l'aide d'un ordinateur de bureau, d'un appareil mobile ou d'une tablette.

Pour éviter d'être bloqué, vous pouvez également utiliser un proxy.

Il peut extraire les métadonnées suivantes :

Endpoint

/metascraping

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
device string L'appareil à utiliser.
proxyCountry string Comté de procuration.

device paramètre prend en charge desktop, mobile et tablet cordes. Si vous ne fournissez pas le paramètre de périphérique, desktop sera utilisé comme option par défaut.

Essayez-le vous-même

Mixed Content

curl --location --request POST 'https://api.geekflare.com/mixedcontent' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  proxyCountry: "us",
  followRedirect: true,
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/mixedcontent",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/mixedcontent"

payload = json.dumps({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": True
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/mixedcontent")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "proxyCountry": "us",
  "followRedirect": true
}';
$request = new Request('POST', 'https://api.geekflare.com/mixedcontent', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657124909949,
  "apiStatus": "success",
  "apiCode": 200,
  "message": "No mixed content found.",
  "meta": {
    "url": "geekflare.com",
    "proxyCountry": "United States",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "l8r16s8k0agfp31wt5i9y7bfzgfpf4ls"
    }
  },
  "data": [
    "https://geekflare.com/",
    "https://geekflare.com/wp-content/themes/geekflare/dist/site.css",
    "https://geekflare.com/wp-content/themes/geekflare/custom/custom.css",
    "https://geekflare.com/wp-content/themes/geekflare/public/site/section/header/logo.png"
  ]
}

L'API de contenu mixte vérifie si un site Web donné charge un ou plusieurs actifs statiques en tant que contenu mixte. Le problème du contenu mixte se pose lorsqu'un site Web charge sa réponse initiale sur https mais charge ensuite une ou plusieurs de ses ressources sur http. C'est plus qu'une question d'hygiène, car le mélange de contenu non sécurisé avec du contenu sécurisé est une grave erreur de sécurité et peut entraîner des attaques sur le chemin et plus encore.

Endpoint

/mixedcontent

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
proxyCountry string Comté de procuration.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

MTR

curl --location --request POST 'https://api.geekflare.com/mtr' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/mtr",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/mtr"

payload = json.dumps({
  "url": "geekflare.com"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/mtr")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com"
}';
$request = new Request('POST', 'https://api.geekflare.com/mtr', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657125115104,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "test": {
      "id": "5cvz40fs08ige3jr15srd6ndl1qkndfc"
    }
  },
  "data": [
    {
      "hop": 1,
      "host": "240.192.18.19",
      "asn": "AS???",
      "loss": 0,
      "sent": 2,
      "last": 0.28,
      "avg": 0.29,
      "best": 0.28,
      "worst": 0.3,
      "stdDev": 0.01
    },
    {
      "hop": 2,
      "host": "240.0.60.49",
      "asn": "AS???",
      "loss": 0,
      "sent": 2,
      "last": 0.28,
      "avg": 0.29,
      "best": 0.28,
      "worst": 0.29,
      "stdDev": 0.01
    },
    {
      "hop": 3,
      "host": "240.0.60.34",
      "asn": "AS???",
      "loss": 0,
      "sent": 2,
      "last": 0.27,
      "avg": 0.29,
      "best": 0.27,
      "worst": 0.31,
      "stdDev": 0.03
    }
  ]
}

L'API MTR peut traceroute domaine ou IP pour vérifier le chemin du réseau.

Endpoint

/mtr

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.

Essayez-le vous-même

Port Scanner

curl --location --request POST 'https://api.geekflare.com/openport' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/openport",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/openport"

payload = json.dumps({
  "url": "geekflare.com"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/openport")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com"
}';
$request = new Request('POST', 'https://api.geekflare.com/openport', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657886341929,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "test": {
      "id": "ug7odkom06u6d3fksph5952mvd09iyrz"
    }
  },
  "data": [80, 443, 8080]
}

L'API Port Scanner vérifie les ports TCP ouverts à la communication sur une adresse IP ou un site donné. Nmap l'alimente et vous disposez de plusieurs options telles que la recherche des principaux ports, des ports uniques ou des plages de ports.

Par défaut, il recherche les 100 premiers ports, mais vous avez la possibilité de modifier cela comme ci-dessous selon les besoins. L'utilisation des 5000 99 premiers ports devrait être efficace à XNUMX % dans la plupart des cas. Vous pouvez vous référer à Documents officiels de Nmap pour la sélection des ports et les stratégies.

Endpoint

/openport

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
topPorts number Nombre de ports principaux à analyser.
portRanges string Analysez uniquement les ports spécifiés pour les plages de ports.

topPorts supports 50, 100, 500, 1000 et 5000. Si vous ne fournissez pas le paramètre topPorts, 100 sera utilisé comme option par défaut.

portRanges prend en charge différents types d'entrée, y compris un seul port comme 22, plusieurs ports comme 22,80,443, et dans une plage comme 80-444.

Ping

curl --location --request POST 'https://api.geekflare.com/ping' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/ping",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/ping"

payload = json.dumps({
  "url": "geekflare.com"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/ping")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com"
}';
$request = new Request('POST', 'https://api.geekflare.com/ping', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657125453687,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "test": {
      "id": "fb3a0b4r09vkc3enmh4p5yq3zii2j5u7"
    }
  },
  "data": {
    "requests": 3,
    "loss": 0,
    "latency": 0.885,
    "min": 0.817,
    "max": 0.885,
    "avg": 0.843,
    "stdDev": 0.029,
    "ip": "104.26.10.88"
  }
}

Le domaine ou l'adresse IP de l'API Ping pour vérifier s'il est accessible et fournir des informations sur la latence. L'API effectue trois requêtes au point de terminaison cible.

Endpoint

/ping

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.

Essayez-le vous-même

Screenshot

curl --location --request POST 'https://api.geekflare.com/screenshot' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  device: "desktop",
  proxyCountry: "us",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/screenshot",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/screenshot"

payload = json.dumps({
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/screenshot")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "device": "desktop",
  "proxyCountry": "us"
}';
$request = new Request('POST', 'https://api.geekflare.com/screenshot', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657125548273,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "device": "desktop",
    "proxyCountry": "United States",
    "test": {
      "id": "qit3lw7b08esp9l3fd1wu42ii2jfrqw6"
    }
  },
  "data": "https://api-assets.geekflare.com/tests/screenshot/kbi6d206g87ituahb7icwtpr.png"
}

L'API Screenshot capture une capture d'écran pleine page d'un site Web à partir d'un appareil et d'un emplacement donnés. Cela aide à connaître l'exactitude du rendu et les performances d'un site Web du point de vue d'utilisateurs répartis géographiquement et disposant de différents appareils.

Endpoint

/screenshot

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
device string Appareil à utiliser.
proxyCountry string Comté de procuration.

device paramètre prend en charge desktop, mobile et tablet cordes. Si vous ne fournissez pas le paramètre de périphérique, desktop sera utilisé comme option par défaut.

Essayez-le vous-même

TLS Scan

curl --location --request POST 'https://api.geekflare.com/tlsscan' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/tlsscan",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/tlsscan"

payload = json.dumps({
  "url": "geekflare.com"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/tlsscan")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com"
})

response = https.request(request)
puts response.read_body

<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com"
}';
$request = new Request('POST', 'https://api.geekflare.com/tlsscan', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657125629493,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "test": {
      "id": "40zt4but04y07ccn4pov5fiolzrxbxdg"
    }
  },
  "data": {
    "protocols": {
      "tls10": false,
      "tls11": false,
      "tls12": true,
      "tls13": true
    },
    "certificate": {
      "commonName": "sni.cloudflaressl.com",
      "subjectAltName": "DNS:*.geekflare.com, DNS:sni.cloudflaressl.com, DNS:geekflare.com",
      "issuer": {
        "country": "US",
        "organization": "Cloudflare, Inc.",
        "commonName": "Cloudflare Inc ECC CA-3"
      },
      "expiry": "Jun  6 23:59:59 2023 GMT"
    }
  }
}

L'API TLS Scan fournit des informations sur les versions TLS prises en charge ainsi que les informations de certificat déployé pour un domaine donné.

Endpoint

/tlsscan

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.

Essayez-le vous-même

Time to First Byte (TTFB)

curl --location --request POST 'https://api.geekflare.com/ttfb' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "followRedirect": true
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  followRedirect: true,
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/ttfb",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/ttfb"

payload = json.dumps({
  "url": "geekflare.com",
  "followRedirect": True
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/ttfb")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "followRedirect": true
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "followRedirect": true
}';
$request = new Request('POST', 'https://api.geekflare.com/ttfb', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657125711631,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "irfdgwvw08mvdaqjyxvkp8apgqzxkyjj"
    }
  },
  "data": 156
}

L'API TTFB mesure la vitesse à laquelle une ressource Web commence à se charger lorsqu'elle est connectée. Cela peut être considéré comme un moyen de mesurer les temps de réponse (en millisecondes), en gros.

Endpoint

/ttfb

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

Site Status (Is site up or down?)

curl --location --request POST 'https://api.geekflare.com/up' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "followRedirect": true,
  "proxyCountry": "us"
}'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  followRedirect: true,
  proxyCountry: "us",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/up",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/up"

payload = json.dumps({
  "url": "geekflare.com",
  "followRedirect": True,
  "proxyCountry": "us"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/up")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "followRedirect": true,
  "proxyCountry": "us"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "followRedirect": true,
  "proxyCountry": "us"
}';
$request = new Request('POST', 'https://api.geekflare.com/up', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1657125793379,
  "apiStatus": "success",
  "apiCode": 200,
  "message": "Site is up.",
  "meta": {
    "url": "geekflare.com",
    "proxyCountry": "United States",
    "followRedirect": true,
    "redirectedURL": "https://geekflare.com/",
    "test": {
      "id": "fsxm0vyw06ztnvbtllwwvimajytf2s8d"
    }
  },
  "data": {
    "statusCode": 200,
    "reasonPhrase": "OK"
  }
}

L'API d'état du site fournit des informations indiquant si l'URL donnée est active ou non. Presque exclusivement, cette API est destinée à fonctionner avec des sites Web. Vérifier l'état d'une infrastructure (dont le point d'entrée est l'URL donnée) n'est pas recommandé et peut donner des résultats erronés.

Endpoint

/up

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
proxyCountry string Comté de procuration.
followRedirect boolean Suivez la redirection.

Essayez-le vous-même

URL Redirection Checker

curl --location --request POST 'https://api.geekflare.com/redirectcheck' \
  --header 'x-api-key: YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "proxyCountry": "us"
}
'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  proxyCountry: "us",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/redirectcheck",
  headers: {
    "x-api-key": "YOUR-API-KEY",
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/redirectcheck"

payload = json.dumps({
  "url": "geekflare.com",
  "proxyCountry": "us"
})
headers = {
  'x-api-key': 'YOUR-API-KEY',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/redirectcheck")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = "YOUR-API-KEY"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "proxyCountry": "us"
})

response = https.request(request)
puts response.read_body

<?php
$client = new GuzzleHttp\Client();
$headers = [
  'x-api-key' => 'YOUR-API-KEY',
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "proxyCountry": "us"
}';
$request = new Request('POST', 'https://api.geekflare.com/redirectcheck', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1661757454309,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "proxyCountry": "United States",
    "test": {
      "id": "667zexrk0aaiabz2rx95b2cxm0khc2s0"
    }
  },
  "data": [
    {
      "url": "http://geekflare.com/",
      "status": 301,
      "headers": [
        {
          "name": "date",
          "value": "Mon, 29 Aug 2022 07:17:31 GMT"
        },
        {
          "name": "location",
          "value": "https://geekflare.com/"
        }
      ]
    },
    {
      "url": "https://geekflare.com/",
      "status": 200,
      "headers": [
        {
          "name": "date",
          "value": "Mon, 29 Aug 2022 07:17:34 GMT"
        },
        {
          "name": "content-type",
          "value": "text/html; charset=UTF-8"
        }
      ]
    }
  ]
}

Vérifiez la redirection sur une page donnée avec son code d'état et ses en-têtes de réponse. Il sera utile de dépanner la façon dont l'URL suit la redirection à partir de plusieurs emplacements et quels codes d'état HTTP et en-têtes de réponse sont renvoyés.

Endpoint

/redirectcheck

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
proxyCountry string Comté de procuration.

Essayez-le vous-même

PDF Generator

curl --location --request POST 'https://api.geekflare.com/url2pdf' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "device": "desktop",
  "format": "letter",
  "orientation": "landscape",
  "margin": {"top": 25.4, "bottom": 25.4},
  "scale": 1.5,
  "proxyCountry": "us"
}
'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  device: "desktop",
  format: "letter",
  orientation: "landscape",
  margin: {
    top: 25.4,
    bottom: 25.4,
  },
  scale: 1.5,
  proxyCountry: "us",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/url2pdf",
  headers: {
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/url2pdf"

payload = json.dumps({
  "url": "geekflare.com",
  "device": "desktop",
  "format": "letter",
  "orientation": "landscape",
  "margin": {
    "top": 25.4,
    "bottom": 25.4
  },
  "scale": 1.5,
  "proxyCountry": "us"
})
headers = {
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/url2pdf")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "device": "desktop",
  "format": "letter",
  "orientation": "landscape",
  "margin": {
    "top": 25.4,
    "bottom": 25.4
  },
  "scale": 1.5,
  "proxyCountry": "us"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "device": "desktop",
  "format": "letter",
  "orientation": "landscape",
  "margin": {
    "top": 25.4,
    "bottom": 25.4
  },
  "scale": 1.5,
  "proxyCountry": "us"
}';
$request = new Request('POST', 'https://api.geekflare.com/url2pdf', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1662121034090,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "device": "desktop",
    "format": "letter",
    "orientation": "landscape",
    "margin": {
      "top": 25.4,
      "bottom": 25.4
    },
    "scale": 1.5,
    "test": {
      "id": "v6cu1pky047wrdkyd1xz8n68f9wtb2xs"
    }
  },
  "data": "https://api-assets.geekflare.com/tests/pdf/o5jiqf08bmp93jsll7vb24vs.pdf"
}

L'API PDF Generator convertit n'importe quelle URL en PDF. Vous pouvez définir l'orientation du fichier sur paysage ou portrait, définir des marges, réduire l'échelle et prendre en charge Proxy.

Endpoint

/url2pdf

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
device string Appareil à utiliser.
format string Format du papier.
orientation string Orientation du papier.
margin object Marges du papier.
scale number Échelle de rendu.
proxyCountry string Comté de procuration.

format paramètre prend en charge letter, legal, a0, a1, a2, a3, a4, a5 et a6 cordes. Si vous ne fournissez pas le paramètre de format, a4 sera utilisé comme option par défaut.

orientation paramètre prend en charge portrait et landscape cordes. Si vous ne fournissez pas le paramètre d'orientation, portrait sera utilisé comme option par défaut.

margin Le paramètre est facultatif et prend en charge le top, right, bottom et left propriétés en millimètres.

scale paramètre prend en charge une valeur comprise entre 0 à 2. Si vous ne fournissez pas le paramètre d'échelle, 1 sera utilisé comme option par défaut.

device paramètre prend en charge desktop, mobile et tablet cordes. Si vous ne fournissez pas le paramètre de périphérique, desktop sera utilisé comme option par défaut.

Essayez-le vous-même

Web Scraping

curl --location --request POST 'https://api.geekflare.com/webscraping' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "url": "geekflare.com",
  "device": "desktop",
  "output": "file",
  "blockAds": false,
  "renderJS": false,
  "proxyCountry": "us"
}
'
var axios = require("axios");
var data = JSON.stringify({
  url: "geekflare.com",
  device: "desktop",
  output: "file",
  blockAds: false,
  renderJS: false,
  proxyCountry: "us",
});

var config = {
  method: "post",
  url: "https://api.geekflare.com/webscraping",
  headers: {
    "Content-Type": "application/json",
  },
  data: data,
};

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data));
  })
  .catch(function (error) {
    console.log(error);
  });
import requests
import json

url = "https://api.geekflare.com/webscraping"

payload = json.dumps({
  "url": "geekflare.com",
  "device": "desktop",
  "output": "file",
  "blockAds": False,
  "renderJS": False,
  "proxyCountry": "us"
})
headers = {
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
require "uri"
require "json"
require "net/http"

url = URI("https://api.geekflare.com/webscraping")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "url": "geekflare.com",
  "device": "desktop",
  "output": "file",
  "blockAds": false,
  "renderJS": false,
  "proxyCountry": "us"
})

response = https.request(request)
puts response.read_body
<?php
$client = new GuzzleHttp\Client();
$headers = [
  'Content-Type' => 'application/json'
];
$body = '{
  "url": "geekflare.com",
  "device": "desktop",
  "output": "file",
  "blockAds": false,
  "renderJS": false,
  "proxyCountry": "us"
}';
$request = new Request('POST', 'https://api.geekflare.com/webscraping', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

L'extrait de code ci-dessus renvoie une réponse JSON comme celle-ci :

{
  "timestamp": 1663337686600,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "device": "desktop",
    "output": "file",
    "blockAds": false,
    "renderJS": false,
    "proxyCountry": "United States",
    "test": {
      "id": "mxqx9v9y0742lap6altwdteqd28t23nq"
    }
  },
  "data": "https://api-assets.geekflare.com/tests/web-scraping/9bulgk075ed9m3vhua5vcrp0.html"
}

L'API Web Scraping vous permet d'extraire des données de n'importe quelle page Web. Vous avez la possibilité d'extraire des données à l'aide d'un appareil de bureau, mobile ou tablette, et il prend en charge le rendu javascript.

Pour éviter d'être bloqué, vous pouvez également utiliser un proxy. L'option par défaut renverra le contenu HTML brut, mais vous pouvez également le sortir dans un fichier HTML.

Endpoint

/webscraping

Paramètres

Nom Catégorie Description
url string L'URL à vérifier.
device string L'appareil à utiliser.
output string Format de la sortie.
blockAds boolean Si les publicités doivent être bloquées ou non.
renderJS boolean Si JavaScript doit être rendu ou non.
proxyCountry string Comté de procuration.

device paramètre prend en charge desktop, mobile et tablet cordes. Si vous ne fournissez pas le paramètre de périphérique, desktop sera utilisé comme option par défaut.

output paramètre prend en charge inline et file cordes. Si vous ne fournissez pas le paramètre de périphérique, inline sera utilisé comme option par défaut.

Essayez-le vous-même