See where a link leads. Understand what it exposes.

Gridinsoft URL Analysis brings page metadata, redirect information and available threat context into one response. Give an investigation more evidence than a domain name alone.

Try URL analysis10 credits per scan · View plans

From submitted link to investigation context

Destination and page

Read the effective URL, available redirect chain, page title, description and language. Inspect the destination behind a submitted link.

Security context

Review available domain assessment, DNS, certificate, registration and detection information alongside the page metadata.

Additional paid analysis

Paid responses include an analysis block with fields for screenshots, network requests, detected hosts, links, cookies and console messages when captured.

Field availability depends on the target and the completed analysis. Screenshots and other artifacts may be null or empty. The presence of a field does not guarantee captured evidence.

Read the response in three parts

BlockWhat it tells you
metadataWhat page was returned: title, description, language and available categories.
securityWhere the link ended and what security context is available. Missing data is not a clean verdict.
analysisAdditional captured evidence on paid plans; null on the free plan.

Full URL analysis can take several seconds or longer depending on the target. Measure your own workload and handle timeouts and errors in your integration.

Choose the level of evidence you need

For a host-level assessment, use Domain Intelligence at 3 credits per check. For regularly refreshed domain datasets, explore Data Feeds.

API subscriptions use our standard terms. Paying for a plan does not make submissions private or remove our rights to use and publish analysis. Private processing, customer-facing services, redistribution, and other special rights require written agreement. Discuss your requirements.

Request and response examples

How to use?

You need to use the HTTP POST method, sending your data in the form of a JSON object within the body of the request.

POST https://inspector.gridinsoft.com/api/v1/url/scan

Each successful scan costs 10 credits. API errors do not consume credits.

Request:

Field Type Description
apikey String Your unique API key that authenticates requests to our services.
url String A full HTTP or HTTPS URL, including its path when relevant

Example:

You can use various tools or libraries to make this POST request. Here’s how you might typically do it using curl, a command-line tool: 

curl -X POST 'https://inspector.gridinsoft.com/api/v1/url/scan' \
    -H 'Content-Type: application/json' \
    -d '{
    "apikey": "YOUR_PRIVATE_APIKEY",
    "url": "https://example.com/path"
    }'

Response:

The JSON response has metadata, security and analysis blocks. Individual fields can be null or empty when information could not be obtained; a missing finding is not a guarantee of safety.

Field Type Description
url String The input URL that was analyzed.
metadata Object Basic information about the page, including title, description, language, and categories.
security Object Critical security indicators:
  • verdict: Available assessment object from Gridinsoft, or null.
  • effective_url: Final destination after all redirects.
  • redirect_chain: Available redirect information.
  • antiviruses_detection: Aggregated detection stats from multiple engines.
  • dns_records: Available DNS records; not a complete DNS history.
  • certificate: Detailed SSL/TLS info (SANs, validity, issuer).
  • jarm & reputation: Advanced technical fingerprints and scores.
analysis Object Additional captured analysis. Available for paid users only; this block is null on the free plan. Individual artifacts may be absent.
  • screenshots: Visual captures (PC & Mobile).
  • network_requests: Captured network request data, when available.
  • cookies & console_logs: Browser environment details.
  • urls_in_html: Available links extracted from the page source.

Response example

Illustrative excerpt using example.com; fields not shown are omitted for readability.

{
  "url": "https://example.com/path",
  "metadata": {"title": "Example page", "description": "", "categories": [], "language": "en"},
  "security": {"effective_url": "https://example.com/path", "redirect_chain": null, "verdict": null},
  "analysis": null
}

A null verdict is unavailable evidence, not a clean verdict. The analysis block is null on a free plan. On paid plans, inspect each artifact for availability before using it.

Allow for variable response times. A full scan can take several seconds or longer; handle HTTP errors and timeouts in your client.

For programming languages

Using one of these samples is the easiest way to start using our API.


import requests

url = "https://inspector.gridinsoft.com/api/v1/url/scan"
data = {
    "apikey": "YOUR_PRIVATE_APIKEY",
    "url": "https://example.com"
}

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


$body = @{ apikey = "YOUR_PRIVATE_APIKEY"; url = "https://example.com" } | ConvertTo-Json
Invoke-RestMethod -Uri "https://inspector.gridinsoft.com/api/v1/url/scan" -Method Post -Body $body -ContentType "application/json"


const response = await fetch("https://inspector.gridinsoft.com/api/v1/url/scan", {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({
        apikey: "YOUR_PRIVATE_APIKEY",
        url: "https://example.com"
    })
});
console.log(await response.json());


val client = OkHttpClient()
val data = """{"apikey":"YOUR_PRIVATE_APIKEY", "url":"https://example.com"}"""
val request = Request.Builder()
    .url("https://inspector.gridinsoft.com/api/v1/url/scan")
    .post(data.toRequestBody("application/json".toMediaType()))
    .build()
println(client.newCall(request).execute().body?.string())


func main() {
    data := []byte(`{"apikey": "YOUR_PRIVATE_APIKEY", "url": "https://example.com"}`)
    resp, _ := http.Post("https://inspector.gridinsoft.com/api/v1/url/scan", "application/json", bytes.NewBuffer(data))
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}


curl -X POST "https://inspector.gridinsoft.com/api/v1/url/scan" \
     -H "Content-Type: application/json" \
     -d '{"apikey": "YOUR_PRIVATE_APIKEY", "url": "https://example.com"}'


require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://inspector.gridinsoft.com/api/v1/url/scan")
response = Net::HTTP.post(uri, {apikey: "YOUR_PRIVATE_APIKEY", url: "https://example.com"}.to_json, "Content-Type" => "application/json")
puts response.body


$ch = curl_init('https://inspector.gridinsoft.com/api/v1/url/scan');
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'apikey' => 'YOUR_PRIVATE_APIKEY',
    'url' => 'https://example.com'
]));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type:application/json']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
echo curl_exec($ch);
curl_close($ch);


using var client = new HttpClient();
var data = new { apikey = "YOUR_PRIVATE_APIKEY", url = "https://example.com" };
var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://inspector.gridinsoft.com/api/v1/url/scan", content);
Console.WriteLine(await res.Content.ReadAsStringAsync());


// Using cpprestsdk
void scan_url() {
    http_client client(U("https://inspector.gridinsoft.com/api/v1/url/scan"));
    json::value data;
    data[U("apikey")] = json::value::string(U("YOUR_PRIVATE_APIKEY"));
    data[U("url")] = json::value::string(U("https://example.com"));

    client.request(methods::POST, U(""), data.serialize(), U("application/json"))
        .then([](http_response res) {
            std::wcout << res.extract_json().get().serialize() << std::endl;
        }).wait();
}


HttpClient client = HttpClient.newHttpClient();
String data = "{\"apikey\":\"YOUR_PRIVATE_APIKEY\", \"url\":\"https://example.com\"}";
HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://inspector.gridinsoft.com/api/v1/url/scan"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(data))
        .build();
System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());


// Use reqwest = { version = "0.11", features = ["blocking", "json"] }
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::blocking::Client::new();
    let res = client.post("https://inspector.gridinsoft.com/api/v1/url/scan")
        .json(&serde_json::json!({"apikey": "YOUR_PRIVATE_APIKEY", "url": "https://example.com"}))
        .send()?;
    println!("{}", res.text()?);
    Ok(())
}


var request = URLRequest(url: URL(string: "https://inspector.gridinsoft.com/api/v1/url/scan")!)
request.httpMethod = "POST"
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: ["apikey": "YOUR_PRIVATE_APIKEY", "url": "https://example.com"])

URLSession.shared.dataTask(with: request) { data, _, _ in
    if let data = data, let result = String(data: data, encoding: .utf8) { print(result) }
}.resume()
Ready to get started?
Sign up to try Inspector API