ChartQuery

Recolher Imagens do Google

Descarregue e catalogue URLs de imagens para qualquer consulta de pesquisa usando a API Autom — útil para construção de datasets, pesquisa visual ou auditorias de ativos de concorrentes.

Visão geral

Este guia mostra como recolher URLs de imagens, títulos e dimensões do Google Imagens para uma determinada consulta. Cada resultado inclui o URL direto da imagem, a página onde foi encontrado, o domínio de origem e as dimensões em píxeis.

Pré-requisitos

  • Uma chave de API Autom — obtenha uma em app.autom.dev
  • Instale as dependências para o seu idioma:
pip install requests

Sem dependências adicionais — utiliza a API fetch nativa (Node 18+).

Extensão curl ativada (ativa por padrão na maioria das instalações PHP).

Sem dependências adicionais — utiliza net/http (Go 1.18+).

Sem dependências adicionais — utiliza java.net.http (Java 11+).

Sem dependências adicionais — utiliza System.Net.Http (.NET 6+).

# Cargo.toml
[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Passos

Pesquisar imagens

Chame GET /v1/google/images com um parâmetro q.

import requests

API_KEY = "YOUR_API_KEY"

response = requests.get(
    "https://api.autom.dev/v1/google/images",
    headers={"x-api-key": API_KEY},
    params={"q": "estação de carregamento de carros elétricos", "gl": "pt", "hl": "pt"},
)
data = response.json()
const API_KEY = "YOUR_API_KEY";

const params   = new URLSearchParams({ q: "estação de carregamento de carros elétricos", gl: "pt", hl: "pt" });
const response = await fetch(`https://api.autom.dev/v1/google/images?${params}`, {
  headers: { "x-api-key": API_KEY },
});
const data = await response.json();
<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["q" => "estação de carregamento de carros elétricos", "gl" => "pt", "hl" => "pt"]);

$ch = curl_init("https://api.autom.dev/v1/google/images?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
package main

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

func main() {
    params := url.Values{"q": {"estação de carregamento de carros elétricos"}, "gl": {"pt"}, "hl": {"pt"}}
    req, _ := http.NewRequest("GET", "https://api.autom.dev/v1/google/images?"+params.Encode(), nil)
    req.Header.Set("x-api-key", "YOUR_API_KEY")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var data map[string]any
    json.Unmarshal(body, &data)
}
import java.net.URI;
import java.net.http.*;

var client  = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.autom.dev/v1/google/images?q=esta%C3%A7%C3%A3o+de+carregamento+de+carros+el%C3%A9tricos&gl=pt&hl=pt"))
    .header("x-api-key", "YOUR_API_KEY")
    .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
using System.Net.Http;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var body = await client.GetStringAsync(
    "https://api.autom.dev/v1/google/images?q=esta%C3%A7%C3%A3o+de+carregamento+de+carros+el%C3%A9tricos&gl=pt&hl=pt");
#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let data = reqwest::Client::new()
        .get("https://api.autom.dev/v1/google/images")
        .header("x-api-key", "YOUR_API_KEY")
        .query(&[("q", "estação de carregamento de carros elétricos"), ("gl", "pt"), ("hl", "pt")])
        .send().await?.json::<serde_json::Value>().await?;

    println!("{:#?}", data);
    Ok(())
}

Inspecionar os resultados de imagens

Cada item em images tem url (imagem direta), link (página de origem), title, domain, source, image_width e image_height.

for img in data.get("images", []):
    print(f"[{img['position']}] {img['title']}")
    print(f"  Imagem : {img['url']}")
    print(f"  Fonte  : {img['source']} — {img['image_width']}x{img['image_height']}px\n")
for (const img of data.images ?? []) {
  console.log(`[${img.position}] ${img.title}`);
  console.log(`  Imagem : ${img.url}`);
  console.log(`  Fonte  : ${img.source} — ${img.image_width}x${img.image_height}px\n`);
}
foreach ($data["images"] ?? [] as $img) {
    echo "[{$img['position']}] {$img['title']}\n";
    echo "  Imagem : {$img['url']}\n";
    echo "  Fonte  : {$img['source']} — {$img['image_width']}x{$img['image_height']}px\n\n";
}
import "fmt"

for _, r := range data["images"].([]any) {
    img := r.(map[string]any)
    fmt.Printf("[%.0f] %s\n  Imagem : %s\n  Fonte  : %s — %.0fx%.0fpx\n\n",
        img["position"], img["title"], img["url"],
        img["source"], img["image_width"], img["image_height"])
}
import org.json.*;

var images = new JSONObject(response.body()).getJSONArray("images");
for (int i = 0; i < images.length(); i++) {
    var img = images.getJSONObject(i);
    System.out.printf("[%d] %s%n  Imagem : %s%n  Fonte  : %s — %dx%dpx%n%n",
        img.getInt("position"), img.getString("title"),
        img.getString("url"), img.getString("source"),
        img.getInt("image_width"), img.getInt("image_height"));
}
using System.Text.Json;

var images = JsonDocument.Parse(body).RootElement.GetProperty("images").EnumerateArray();
foreach (var img in images)
{
    Console.WriteLine($"[{img.GetProperty("position")}] {img.GetProperty("title")}");
    Console.WriteLine($"  Imagem : {img.GetProperty("url")}");
    Console.WriteLine($"  Fonte  : {img.GetProperty("source")} — {img.GetProperty("image_width")}x{img.GetProperty("image_height")}px\n");
}
if let Some(images) = data["images"].as_array() {
    for img in images {
        println!("[{}] {}", img["position"], img["title"].as_str().unwrap_or(""));
        println!("  Imagem : {}", img["url"].as_str().unwrap_or(""));
        println!("  Fonte  : {} — {}x{}px\n",
            img["source"].as_str().unwrap_or(""), img["image_width"], img["image_height"]);
    }
}

Construir um catálogo de imagens filtrado por tamanho mínimo

Filtre miniaturas e guarde apenas imagens de alta resolução.

import csv, requests

API_KEY    = "YOUR_API_KEY"
QUERY      = "estação de carregamento de carros elétricos"
MIN_WIDTH  = 800

def fetch_images(query: str, pages: int = 2) -> list:
    results = []
    for page in range(1, pages + 1):
        r = requests.get("https://api.autom.dev/v1/google/images",
            headers={"x-api-key": API_KEY},
            params={"q": query, "gl": "pt", "hl": "pt", "page": page})
        results.extend(r.json().get("images", []))
    return results

large = [img for img in fetch_images(QUERY) if img.get("image_width", 0) >= MIN_WIDTH]

with open("catalogo_imagens.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["position", "title", "url", "source", "image_width", "image_height"])
    writer.writeheader()
    writer.writerows(large)

print(f"Guardadas {len(large)} imagens de alta resolução em catalogo_imagens.csv")
import { writeFileSync } from "fs";

const API_KEY   = "YOUR_API_KEY";
const MIN_WIDTH = 800;

async function fetchImages(query: string, pages = 2): Promise<any[]> {
  const all: any[] = [];
  for (let page = 1; page <= pages; page++) {
    const params = new URLSearchParams({ q: query, gl: "pt", hl: "pt", page: String(page) });
    const res    = await fetch(`https://api.autom.dev/v1/google/images?${params}`, {
      headers: { "x-api-key": API_KEY },
    });
    all.push(...((await res.json()).images ?? []));
  }
  return all;
}

const images = await fetchImages("estação de carregamento de carros elétricos");
const large  = images.filter(img => (img.image_width ?? 0) >= MIN_WIDTH);
writeFileSync("catalogo_imagens.json", JSON.stringify(large, null, 2));
console.log(`Guardadas ${large.length} imagens de alta resolução em catalogo_imagens.json`);
<?php
$apiKey   = "YOUR_API_KEY";
$query    = "estação de carregamento de carros elétricos";
$minWidth = 800;

function fetchImages(string $apiKey, string $query, int $pages = 2): array {
    $all = [];
    for ($page = 1; $page <= $pages; $page++) {
        $params = http_build_query(["q" => $query, "gl" => "pt", "hl" => "pt", "page" => $page]);
        $ch = curl_init("https://api.autom.dev/v1/google/images?{$params}");
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
        $data = json_decode(curl_exec($ch), true);
        curl_close($ch);
        $all = array_merge($all, $data["images"] ?? []);
    }
    return $all;
}

$large = array_filter(fetchImages($apiKey, $query), fn($img) => ($img["image_width"] ?? 0) >= $minWidth);
file_put_contents("catalogo_imagens.json", json_encode(array_values($large), JSON_PRETTY_PRINT));
echo "Guardadas " . count($large) . " imagens de alta resolução em catalogo_imagens.json\n";
package main

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

func fetchImages(apiKey, query string, pages int) []map[string]any {
    var all []map[string]any
    for page := 1; page <= pages; page++ {
        params := url.Values{"q": {query}, "gl": {"pt"}, "hl": {"pt"}, "page": {strconv.Itoa(page)}}
        req, _ := http.NewRequest("GET", "https://api.autom.dev/v1/google/images?"+params.Encode(), nil)
        req.Header.Set("x-api-key", apiKey)
        resp, _ := http.DefaultClient.Do(req)
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()

        var data map[string]any
        json.Unmarshal(body, &data)
        for _, r := range data["images"].([]any) {
            all = append(all, r.(map[string]any))
        }
    }
    return all
}

func main() {
    images   := fetchImages("YOUR_API_KEY", "estação de carregamento de carros elétricos", 2)
    minWidth := float64(800)
    var large []map[string]any
    for _, img := range images {
        if img["image_width"].(float64) >= minWidth {
            large = append(large, img)
        }
    }
    b, _ := json.MarshalIndent(large, "", "  ")
    os.WriteFile("catalogo_imagens.json", b, 0644)
    fmt.Printf("Guardadas %d imagens de alta resolução em catalogo_imagens.json\n", len(large))
}
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import org.json.*;

public class Main {
    public static void main(String[] args) throws Exception {
        var apiKey   = "YOUR_API_KEY";
        var query    = URLEncoder.encode("estação de carregamento de carros elétricos", StandardCharsets.UTF_8);
        var minWidth = 800;
        var client   = HttpClient.newHttpClient();
        var all      = new JSONArray();

        for (int page = 1; page <= 2; page++) {
            var url  = "https://api.autom.dev/v1/google/images?q=" + query + "&gl=pt&hl=pt&page=" + page;
            var req  = HttpRequest.newBuilder().uri(URI.create(url))
                .header("x-api-key", apiKey).GET().build();
            var resp = client.send(req, HttpResponse.BodyHandlers.ofString());
            var imgs = new JSONObject(resp.body()).getJSONArray("images");
            for (int i = 0; i < imgs.length(); i++) all.put(imgs.get(i));
        }

        var large = new JSONArray();
        for (int i = 0; i < all.length(); i++) {
            var img = all.getJSONObject(i);
            if (img.getInt("image_width") >= minWidth) large.put(img);
        }
        Files.writeString(Path.of("catalogo_imagens.json"), large.toString(2));
        System.out.println("Guardadas " + large.length() + " imagens de alta resolução em catalogo_imagens.json");
    }
}
using System.Net.Http;
using System.Text.Json;

var apiKey   = "YOUR_API_KEY";
var minWidth = 800;
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", apiKey);

var all = new List<JsonElement>();
for (int page = 1; page <= 2; page++)
{
    var body = await client.GetStringAsync(
        $"https://api.autom.dev/v1/google/images?q=esta%C3%A7%C3%A3o+de+carregamento+de+carros+el%C3%A9tricos&gl=pt&hl=pt&page={page}");
    var json = JsonDocument.Parse(body).RootElement;
    foreach (var img in json.GetProperty("images").EnumerateArray())
        all.Add(img);
}

var large = all.Where(img => img.GetProperty("image_width").GetInt32() >= minWidth).ToList();
File.WriteAllText("catalogo_imagens.json", JsonSerializer.Serialize(large, new JsonSerializerOptions { WriteIndented = true }));
Console.WriteLine($"Guardadas {large.Count} imagens de alta resolução em catalogo_imagens.json");
use reqwest::Client;
use serde_json::Value;
use std::fs;

async fn fetch_images(client: &Client, api_key: &str, query: &str, pages: u32) -> Vec<Value> {
    let mut all = Vec::new();
    for page in 1..=pages {
        let data = client.get("https://api.autom.dev/v1/google/images")
            .header("x-api-key", api_key)
            .query(&[("q", query), ("gl", "pt"), ("hl", "pt"), ("page", &page.to_string())])
            .send().await.unwrap().json::<Value>().await.unwrap();
        if let Some(imgs) = data["images"].as_array() { all.extend(imgs.clone()); }
    }
    all
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let images = fetch_images(&client, "YOUR_API_KEY", "estação de carregamento de carros elétricos", 2).await;
    let large: Vec<&Value> = images.iter()
        .filter(|img| img["image_width"].as_i64().unwrap_or(0) >= 800)
        .collect();
    fs::write("catalogo_imagens.json", serde_json::to_string_pretty(&large).unwrap()).unwrap();
    println!("Guardadas {} imagens de alta resolução em catalogo_imagens.json", large.len());
    Ok(())
}

O campo url em cada resultado é o link direto para o ficheiro de imagem. Verifique sempre que tem os direitos necessários para usar uma imagem antes de a incluir num dataset ou produto.

Nesta página

Visão geralPré-requisitosPassosPesquisar imagensInspecionar os resultados de imagensConstruir um catálogo de imagens filtrado por tamanho mínimo