NAV
cURL Node.js Python Rubí PHP

Descripción

Introduction

Esta es la documentación oficial para el API REST de Geekflare.

Estas API brindan numerosas capacidades para importantes métodos de prueba y monitoreo para sitios web. Por ejemplo, el rendimiento del sitio web, la seguridad, el DNS y la puntuación de SEO son algunas de las capacidades que ofrecen estas API.

Getting started

Comenzar con la API de Geekflare es muy fácil. Deberá registrarse (no se requiere tarjeta de crédito) para obtener acceso al nivel gratuito de Geekflare.

Una vez que tenga una clave API, puede explorar la Colección Cartero para probar las API.

Obtenga su clave API

API type

La API de Geekflare es una REST API. Eso significa que funciona sobre HTTP y acepta y devuelve datos en el JSON formato.

Rate (usage) limits

La API de Geekflare permite una tasa de llamadas de 25 llamadas API por segundo bajo el plan premium para cada cliente que tenga un token válido.

Proxy county

Muchos de los API de Geekflare solicitud de soporte a través de proxy. En caso de que necesite utilizar esta función, el proxy que se proporcionará como proxyCountry parámetro.

Aquí hay una lista de los países admitidos:

País Code
Estados Unidos us
United Kingdom uk
Francia fr
Alemania de
Canada ca
India in
China cn
Brasil br
España es
Japón jp

Request

Autenticación

Asegúrese de que esté presente en el valor de su encabezado cuando realice llamadas a la API.

x-api-key YOUR-API-KEY

Espera que la clave de acceso a la API esté presente en un encabezado de solicitud llamado x-api-key.

URL base

Para todos los puntos finales enumerados en esta documentación, la URL base es https://api.geekflare.com

Response

La respuesta de la API sigue algunos formatos comunes en aras de la claridad y la coherencia. Según el estado de la solicitud, las estructuras de respuesta son las siguientes.

En el procesamiento exitoso de una solicitud, la API devuelve una respuesta en el siguiente formato:

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

Cuando la solicitud entrante no tiene la autorización adecuada, se devuelve la siguiente estructura de respuesta:

{
  "message": "Forbidden"
}

Si tiene un plan gratuito e intenta acceder a una API de pago como Port Scanner, devolverá un error en el siguiente formato:

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

Si se proporciona un punto final incorrecto o un tipo de solicitud incorrecto (POST en lugar de GET, por ejemplo), la API devuelve un error en el siguiente formato:

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

Puntos finales de API

La API de Geekflare se compone de los siguientes puntos finales.

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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
    }
  ]
}

La API Broken Link Checker comprueba si la página web contiene enlaces rotos.

Punto final

/brokenlink

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
proxyCountry string condado apoderado.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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
      }
    ]
  }
}

La API de registros DNS extrae y muestra los registros DNS de un nombre de dominio determinado.

Punto final

/dnsrecord

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
types string[] Tipo(s) de registros DNS.

types El parámetro admite las siguientes cadenas.

Si no proporciona el types parámetro, mostrará todos los registros DNS.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

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

La API DNSSEC prueba si la extensión de seguridad está habilitada en el dominio.

Punto final

/dnssec

parámetros

Nombre Tipo Descripción
url string La URL que se va a probar.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
    }
  ]
}

La API de encabezado HTTP analiza los encabezados de respuesta de un punto final determinado (o sitio web) y presenta el resultado en formato JSON. Esto puede ser útil en actividades como monitoreo, recolección de datos, etc.

Punto final

/httpheader

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
proxyCountry string condado apoderado.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"]
  }
}

Si bien la especificación HTTP está en constante evolución, los servidores web (por falta de configuración o capacidad) no siempre pueden mantenerse al día. Esta API prueba un punto final HTTP e informa qué versiones HTTP son compatibles actualmente con ese punto final.

Punto final

/httpprotocol

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
}

La API de Lighthouse brinda acceso al proyecto Google Lighthouse como una API. Lighthouse es una herramienta de auditoría para sitios web para calificarlos en rendimiento, accesibilidad, SEO, etc., al tiempo que brinda sugerencias de mejora concretas.

Punto final

/lighthouse

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
device string El dispositivo a utilizar.
parameters string[] Parámetros del faro.
proxyCountry string condado apoderado.
followRedirect boolean Siga la redirección.

device soportes de parámetros desktop, mobile y tablet instrumentos de cuerda. Si no proporciona el parámetro del dispositivo, desktop se utilizará como una opción predeterminada.

Modo avanzado

La API de Lighthouse también se ejecuta en un modo avanzado, aceptando algunos de los parámetros de personalización reconocidos por el motor Lighthouse de Google:

La --output El parámetro controla el formato de salida. está configurado para json por defecto, pero puede ser html or csv .

Para utilizar estos parámetros, páselos en unparameters Matriz JSON en el cuerpo de la entrada. puede referirse guía para ejecutar la API de Lighthouse usando el modo avanzado.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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
  }
}

La API de tiempo de carga proporciona el tiempo total (en milisegundos) que tarda en completarse una respuesta HTTP. Esto se usa a menudo para medir el rendimiento del sitio web e incluye el tiempo necesario para la búsqueda de DNS, la espera de que el servidor responda, los datos enviados, los datos recibidos, etc.

Por defecto, la conexión se realiza desde servidores ubicados en USA. Sin embargo, para medir el tiempo de carga de otros países como Francia, Reino Unido, China, India, etc., puede usar un parámetro de proxy que se menciona a continuación.

Punto final

/loadtime

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
proxyCountry string condado apoderado.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

Meta Scraping

curl --location -g --request POST 'https://api.geekflare.com/metascraping' \
  --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/metascraping",
  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/metascraping"

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/metascraping")

http = Net::HTTP.new(url.host, url.port);
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 = http.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/metascraping', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "timestamp": 1663336951774,
  "apiStatus": "success",
  "apiCode": 200,
  "meta": {
    "url": "geekflare.com",
    "device": "desktop",
    "proxyCountry": "United States",
    "test": {
      "id": "ajfenqnl05l9dd8vh9zb2ffprr5g9k7o"
    }
  },
  "data": {
    "url": "https://geekflare.com/",
    "date": "Thu, 26 Jan 2023 18:58:40 GMT",
    "lang": "en-us",
    "title": "Geekflare - Your trusted source for Technology Resources",
    "description": "Geekflare is an online publication that produces high-quality articles on Technology, Business, and Fintech and makes Tools and APIs to help businesses and people grow.",
    "headline": "Technology Resources",
    "logo": "https://geekflare.com/wp-content/uploads/2020/01/Geekflare-logo.png",
    "image": "https://geekflare.com/wp-content/uploads/2019/06/Geekflare-social.png",
    "author": "Chandan Kumar",
    "publisher": "Geekflare",
    "feed": "https://geekflare.com/feed/"
  }
}

Meta Scraping API le permite extraer metadatos de cualquier página web. Puede extraer datos de un sitio web utilizando un dispositivo de escritorio, móvil o tableta.

Para evitar que te bloqueen, también puedes usar un proxy.

Puede extraer los siguientes metadatos:

Punto final

/metascraping

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
device string El dispositivo a utilizar.
proxyCountry string condado apoderado.

device soportes de parámetros desktop, mobile y tablet instrumentos de cuerda. Si no proporciona el parámetro del dispositivo, desktop se utilizará como una opción predeterminada.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
  ]
}

La API de contenido mixto comprueba si un sitio web determinado carga uno o más activos estáticos como contenido mixto. El problema del contenido mixto surge cuando un sitio web carga su respuesta inicial sobre https pero luego carga uno o más de sus recursos sobre http. Esto es más que una cuestión de higiene, ya que mezclar contenido no seguro con contenido seguro es un grave error de seguridad y puede resultar en ataques en ruta y más.

Punto final

/mixedcontent

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
proxyCountry string condado apoderado.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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
    }
  ]
}

La API de MTR puede rastrear el dominio de la ruta o la IP para verificar la ruta de la red.

Punto final

/mtr

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

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

La API de Port Scanner verifica los puertos TCP abiertos para la comunicación en una IP o sitio determinado. Nmap lo potencia y tiene múltiples opciones, como escanear puertos principales, puertos únicos o rangos de puertos.

De forma predeterminada, busca los 100 puertos principales, pero tiene la opción de cambiarlo como se indica a continuación según los requisitos. El uso de los 5000 puertos principales debería tener una eficacia del 99 % en la mayoría de los casos. Puedes referirte a Documentos oficiales de Nmap para selección de puertos y estrategias.

Punto final

/openport

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
topPorts number Número de puertos principales que se escanearán.
portRanges string Escanee solo los puertos especificados en busca de rangos de puertos.

topPorts apoya 50, 100, 500, 1000 y 5000. Si no proporciona el parámetro topPorts, 100 se utilizará como una opción predeterminada.

portRanges admite diferentes tipos de entrada, incluido un solo puerto como 22, múltiples puertos como 22,80,443, y en un rango como 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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
  }
}

El dominio o IP de ping de la API de Ping para comprobar si es accesible y proporcionar información de latencia. La API realiza tres solicitudes al punto final de destino.

Punto final

/ping

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
}

La API de captura de pantalla toma una captura de pantalla de página completa de un sitio web desde un dispositivo y una ubicación determinados. Esto ayuda a conocer la corrección de la representación y el rendimiento de un sitio web desde la perspectiva de usuarios distribuidos geográficamente que tienen diferentes dispositivos.

Punto final

/screenshot

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
device string Dispositivo a utilizar.
fullPage boolean Tomar captura de pantalla de página completa.
blockAds boolean Bloquear anuncios.
hideCookie boolean Ocultar ventanas emergentes de cookies.
skipCaptcha boolean Intenta omitir el captcha.
addTimestamp boolean Agregar marca de agua de marca de tiempo.
proxyCountry string condado apoderado.

device soportes de parámetros desktop, mobile y tablet instrumentos de cuerda. Si no proporciona el parámetro del dispositivo, desktop se utilizará como una opción predeterminada.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
    }
  }
}

La API de exploración de TLS proporciona información sobre las versiones de TLS admitidas, así como la información del certificado implementado para un dominio determinado.

Punto final

/tlsscan

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

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

La API TTFB mide qué tan rápido comienza a cargarse un recurso web cuando está conectado. Se puede considerar como una forma de medir los tiempos de respuesta (en milisegundos), en términos generales.

Punto final

/ttfb

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
  }
}

La API de estado del sitio proporciona información sobre si la URL dada está activa o no. Casi exclusivamente, esta API está destinada a funcionar con sitios web. No se recomienda comprobar el estado de una infraestructura (cuyo punto de entrada es la URL dada) y puede proporcionar resultados erróneos.

Punto final

/up

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
proxyCountry string condado apoderado.
followRedirect boolean Siga la redirección.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
        }
      ]
    }
  ]
}

Verifique la redirección en una página determinada con su código de estado y encabezados de respuesta. Será útil para solucionar el problema de cómo la URL sigue la redirección desde varias ubicaciones y qué códigos de estado HTTP y encabezados de respuesta se devuelven.

Punto final

/redirectcheck

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
proxyCountry string condado apoderado.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
}

La API PDF Generator convierte cualquier URL a PDF. Puede establecer la orientación del archivo en horizontal o vertical, establecer márgenes, reducir la escala y es compatible con Proxy.

Punto final

/url2pdf

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
device string Dispositivo a utilizar.
format string Formato del papel.
orientation string Orientación del papel.
margin object Márgenes del papel.
scale number Escala de representación.
hideCookie boolean Ocultar ventanas emergentes de cookies.
skipCaptcha boolean Intenta omitir el captcha.
addTimestamp boolean Agregar marca de agua de marca de tiempo.
proxyCountry string condado apoderado.

format soportes de parámetros letter, legal, a0, a1, a2, a3, a4, a5 y a6 instrumentos de cuerda. Si no proporciona el parámetro de formato, a4 se utilizará como una opción predeterminada.

orientation soportes de parámetros portrait y landscape instrumentos de cuerda. Si no proporciona el parámetro de orientación, portrait se utilizará como una opción predeterminada.

margin El parámetro es opcional y admite el top, right, bottom y left Propiedades en milímetros.

scale parámetro admite un valor entre 0 a 2. Si no proporciona el parámetro de escala, 1 se utilizará como una opción predeterminada.

device soportes de parámetros desktop, mobile y tablet instrumentos de cuerda. Si no proporciona el parámetro del dispositivo, desktop se utilizará como una opción predeterminada.

Inténtalo tú mismo

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();

El fragmento anterior devuelve una respuesta JSON como esta:

{
  "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"
}

Web Scraping API le permite extraer datos de cualquier página web. Tiene la opción de extraer datos utilizando un dispositivo de escritorio, móvil o tableta, y es compatible con la representación de JavaScript.

Para evitar que te bloqueen, también puedes usar un proxy. La opción predeterminada devolverá el contenido HTML sin procesar, pero también puede enviarlo a un archivo HTML.

Punto final

/webscraping

parámetros

Nombre Tipo Descripción
url string La URL que se va a comprobar.
device string El dispositivo a utilizar.
output string Formato de la salida.
blockAds boolean Si los anuncios deben bloquearse o no.
renderJS boolean Si se debe representar JavaScript o no.
proxyCountry string condado apoderado.

device soportes de parámetros desktop, mobile y tablet instrumentos de cuerda. Si no proporciona el parámetro del dispositivo, desktop se utilizará como una opción predeterminada.

output soportes de parámetros inline y file instrumentos de cuerda. Si no proporciona el parámetro del dispositivo, inline se utilizará como una opción predeterminada.

Inténtalo tú mismo