API di dominio BuiltWith

Devi login O iscrizione per utilizzare l'API BuiltWith. Dopo aver effettuato l'accesso, la tua chiave API effettiva verrà mostrata qui.

L'API BuiltWith Domain fornisce l'accesso XML, JSON, CSV, XLSX alle informazioni tecnologiche di un sito Web, che includono tutte le informazioni tecniche reperibili nelle ricerche dettagliate su builtwith.com e metadati aggiuntivi, ove disponibili.

Reference https://api.builtwith.com/llms.txt and
https://raw.githubusercontent.com/builtwith/builtwith-ai-sdk/refs/heads/main/README.md
Add builtwith AI api to my app as a client. Make a call to the domain API for the domain hotelscombined.com

È necessario fornire la chiave API in ogni ricerca. I nostri endpoint sono solo HTTPS e forniscono la crittografia delle chiavi. Non esporre mai la tua chiave API.

La tua chiave API è
00000000-0000-0000-0000-000000000000

Puoi fornire la tua chiave come parametro di stringa di query o come intestazione HTTP:

• Stringa di query: ?KEY=00000000-0000-0000-0000-000000000000
• Intestazione HTTP: Authorization: API 00000000-0000-0000-0000-000000000000

• 64 Solo domini radice o sottodomini Per ricerca
• Testo, Meta, Attributi, Contatti tutti rimossi
• Rimuove la ricerca in tempo reale dei risultati se non sono presenti nel nostro database

Per una produttività ancora maggiore contattaci sulle soluzioni endpoint dedicate.

Invia un elenco JSON di domini radice. I batch di piccole dimensioni restituiscono risultati immediati; i batch di grandi dimensioni restituiscono un ID di processo per l'elaborazione in background.

La risposta sincrona (piccoli batch) corrisponde al formato di risposta dell'API di dominio.

Esempio di risposta asincrona:

Controlla lo stato del lavoro:

Esempio di risposta di stato:

Recupera i risultati (download una tantum):

La risposta del risultato è un array JSON di oggetti risultato del dominio. I risultati vengono eliminati dopo il primo accesso.

È possibile inserire un elenco di domini radice nel sistema di ricerca in blocco anziché effettuare richieste GET.

Ecco alcuni esempi di implementazione in diversi linguaggi di programmazione per effettuare richieste API:

• C#
• Python
• PHP
• Node.js
• Java
• Ruby
• Go
• cURL

var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("https://api.builtwith.com/v26/api.json" +
        "?KEY=00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

import requests
url = "https://api.builtwith.com/v26/api.json"
params = {
    "KEY": "00000000-0000-0000-0000-000000000000",
    "LOOKUP": "wayfair.com"
}
response = requests.get(url, params=params)
response.raise_for_status()
print(response.text)

<?php
$url = "https://api.builtwith.com/v26/api.json?KEY=
                        00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com";
$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Accept: application/json"
    ]
]);
$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
if ($httpCode === 200) {
    echo $response;
} else {
    echo "Error: HTTP " . $httpCode;
}
?>

const url = "https://api.builtwith.com/v26/api.json?KEY=" +
                        "00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com";
fetch(url)
    .then(response => {
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return response.text();
    })
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.error('Error:', error);
    });

import java.net.URI;

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class ApiExample {
    public static void main(String[] args) throws Exception {
        String url = "https://api.builtwith.com/v26/api.json?KEY=
                        00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .GET()
                .build();
        HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() == 200) {
            System.out.println(response.body());
        } else {
            System.err.println("Error: HTTP " + response.statusCode());
        }
    }
}

require 'net/http'
require 'uri'
url = URI('https://api.builtwith.com/v26/api.json?KEY=
                        00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com')
begin
  response = Net::HTTP.get_response(url)
  if response.code == '200'
    puts response.body
  else
    puts "Error: HTTP #{response.code}"
  end
rescue StandardError => e
  puts "Error: #{e.message}"
end

package main
import (
    "fmt"
    "io"
    "net/http"
)
func main() {
    url := "https://api.builtwith.com/v26/api.json?KEY=
                        00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com"
    resp, err := http.Get(url)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusOK {
        fmt.Printf("Error: HTTP %d\n", resp.StatusCode)
        return
    }
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading response: %v\n", err)
        return
    }
    fmt.Println(string(body))
}

curl -X GET \
  "https://api.builtwith.com/v26/api.json?KEY=
                        00000000-0000-0000-0000-000000000000&LOOKUP=wayfair.com" \
  -H "Accept: application/json"
# Alternative with URL parameters separated for readability:
curl -G \
  "https://api.builtwith.com/v26/api.json" \
  -d "KEY=00000000-0000-0000-0000-000000000000" \
  -d "LOOKUP=wayfair.com" \
  -H "Accept: application/json"

Node.js NPM

https://www.npmjs.com/package/builtwith-api
NPM pacchetto di Zach Caceres - https://github.com/zcaceres/builtwith-api

Microsoft .NET Nuget

https://www.nuget.org/packages/BuiltWith/
C# pacchetto di BuiltWith Pty Ltd - https://github.com/builtwith/BuiltWith-C-Client-API

Esempi di codice

https://github.com/builtwith/code-examples
Esempi di tutti gli endpoint API in più lingue

Massimo 8 richieste contemporanee, con un massimo di 10 richieste al secondo. Assicurati di non superare questo limite, altrimenti riceverai errori 429.

Per le rimozioni con limite di velocità contattaci sulle soluzioni endpoint dedicate.

Si noti che i messaggi di errore in questo formato non possono essere garantiti; l'implementazione dovrebbe considerare anche i codici di risposta diversi da 200 come errori. La proprietà Lookup sarà null (json) o non fornita (xml) se l'errore è correlato al server. Visualizza tutti i potenziali codici di errore ben formati.

Nostro termini standard coprono l'utilizzo di tutte le nostre API.

In generale, puoi utilizzare l'API per migliorare il tuo prodotto in molti modi. L'unica limitazione è che non puoi rivendere i dati così come sono o fornire funzionalità duplicate a builtwith.com e ai suoi servizi associati.

Le operazioni contrassegnate come tecnologie hanno sempre un punteggio di affidabilità pari a 0,5, che prevale sulle regole relative a frodi/scommesse, operazioni parcheggiate e operazioni una tantum. Tutti gli altri record tecnologici partono da 1. I formati JSON e XML espongono il livello di affidabilità; i formati CSV ed Excel includono una colonna per la valutazione dell'affidabilità.

• Una tecnologia attiva il cui nome termina con 'scam' o è uguale a 'Gambling Content' imposta tutti i punteggi tecnologici a 0, ad eccezione delle tecnologie scam e Gambling Content e dei record contrassegnati con i tag hosting, mx, parked, registrar, ns o Server.
• Una tecnologia attiva contrassegnata come "parcheggiata" sottrae 0,5 da ogni punteggio, ad eccezione delle tecnologie contrassegnate come "parcheggiate" o "in hosting".
• Un rilevamento una tantum, in cui FirstDetected è uguale a LastDetected, sottrae 0,25, anche per le tecnologie esenti dalle regole relative a frodi/gioco d'azzardo o dispositivi parcheggiati, ad eccezione delle operazioni.

Le detrazioni si sommano e i punteggi non scendono mai al di sotto di 0. Attivo significa che LastDetected è successivo all'attuale limite di aggiornamento completo del database, come utilizzato da LIVEONLY. I segnali di truffa/gioco d'azzardo e di sito parcheggiato si applicano a tutti i percorsi del dominio di ricerca, prima dei filtri per data o solo per i siti attivi. Ad esempio, un'analisi una tantum con tag tecnologico su un sito parcheggiato ottiene un punteggio di 0,25. Le versioni API precedenti rimangono disponibili.