Autocomplete do YouTube

Aprenda como obter sugestões de termos de busca do YouTube usando a Web Scraper API. Saiba mais sobre seus parâmetros e veja uma requisição de exemplo.

Com o youtube_autocomplete source, os usuários podem obter sugestões de palavras-chave relacionadas para qualquer termo de pesquisa de sua escolha. Essas sugestões podem ser usadas com o youtube_search source para descobrir vídeos mais relevantes e expandir seus fluxos de dados do YouTube.

Amostras de requisição

Os exemplos a seguir demonstram como recuperar sugestões de termos de pesquisa para uma consulta dada.

curl 'https://realtime.oxylabs.io/v1/queries' \
--user 'USERNAME:PASSWORD' \
-H 'Content-Type: application/json' \
-d '{
        "source": "youtube_autocomplete",
        "query": "what is",
        "language": "en",
        "location": "US"
    }'

import requests
from pprint import pprint

# Estruturar payload.
payload = {
    "source": "youtube_autocomplete",
    "query": "what is",
    "language": "en",
    "location": "US"
}

# Obter resposta.
response = requests.request(
    "POST",
    "https://realtime.oxylabs.io/v1/queries",
    auth=("USERNAME", "PASSWORD"),
    json=payload,
)

# Imprima a resposta JSON com o resultado.
pprint(response.json())

const https = require("https");

const username = "USERNAME";
const password = "PASSWORD";
const body = {
    source: "youtube_autocomplete",
    query: "what is",
    language: "en",
    location: "US"
};

const options = {
    hostname: "realtime.oxylabs.io",
    path: "/v1/queries",
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        Authorization:
            "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
    },
};

const request = https.request(options, (response) => {
    let data = "";

    response.on("data", (chunk) => {
        data += chunk;
    });

    response.on("end", () => {
        const responseData = JSON.parse(data);
        console.log(JSON.stringify(responseData, null, 2));
    });
});

request.on("error", (error) => {
    console.error("Error:", error);
});

request.write(JSON.stringify(body));
request.end();

# Toda a string que você enviar precisa estar codificada em URL.
https://realtime.oxylabs.io/v1/queries?source=youtube_autocomplete&query=what%20is&language=en&location=US&access_token=12345abcde

<?php

$params = array(
    'source' => 'youtube_autocomplete',
    'query' => 'what is',
    'language' => 'en',
    'location' => 'US'
);

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://realtime.oxylabs.io/v1/queries");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($params));
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, "USERNAME" . ":" . "PASSWORD");

$headers = array();
$headers[] = "Content-Type: application/json";
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
echo $result;

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}

curl_close($ch);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	const Username = "USERNAME"
	const Password = "PASSWORD"

	// Defina o payload
	payload := map[string]interface{}{
		"source":   "youtube_autocomplete",
		"query":    "what is",
		"language": "en",
		"location": "US",
	}

	jsonValue, err := json.Marshal(payload)
	if err != nil {
		fmt.Println("Erro ao serializar JSON:", err)
		return
	}

	client := &http.Client{}
	request, err := http.NewRequest("POST", "https://realtime.oxylabs.io/v1/queries", bytes.NewBuffer(jsonValue))
	if err != nil {
		fmt.Println("Erro ao criar requisição:", err)
		return
	}

	request.SetBasicAuth(Username, Password)
	request.Header.Set("Content-Type", "application/json")

	response, err := client.Do(request)
	if err != nil {
		fmt.Println("Erro ao fazer requisição:", err)
		return
	}
	defer response.Body.Close()

	responseText, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println("Erro ao ler resposta:", err)
		return
	}

	fmt.Println(string(responseText))
}

using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text;
using System.Threading.Tasks;

namespace OxyApi
{
    class Program
    {
        static async Task Main()
        {
            const string Username = "USERNAME";
            const string Password = "PASSWORD";

            var parameters = new
            {
                source = "youtube_autocomplete",
                query = "what is",
                language = "en",
                location = "US"
            };

            var client = new HttpClient();

            Uri baseUri = new Uri("https://realtime.oxylabs.io");
            client.BaseAddress = baseUri;

            var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/v1/queries");
            requestMessage.Content = JsonContent.Create(parameters);

            var authenticationString = $"{Username}:{Password}";
            var base64EncodedAuthenticationString = Convert.ToBase64String(Encoding.UTF8.GetBytes(authenticationString));
            requestMessage.Headers.Add("Authorization", "Basic " + base64EncodedAuthenticationString);

            try
            {
                var response = await client.SendAsync(requestMessage);
                response.EnsureSuccessStatusCode();

                var contents = await response.Content.ReadAsStringAsync();
                Console.WriteLine(contents);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Erro na requisição: {e.Message}");
            }
        }
    }
}

package org.example;

import okhttp3.*;
import org.json.JSONObject;
import java.util.concurrent.TimeUnit;

public class Main implements Runnable {
    private static final String AUTHORIZATION_HEADER = "Authorization";
    public static final String USERNAME = "USERNAME";
    public static final String PASSWORD = "PASSWORD";

    public void run() {
        // Construir payload JSON
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("source", "youtube_autocomplete");
        jsonObject.put("query", "what is");
        jsonObject.put("language", "en");
        jsonObject.put("location", "US");

        Authenticator authenticator = (route, response) -> {
            String credential = Credentials.basic(USERNAME, PASSWORD);
            return response
                    .request()
                    .newBuilder()
                    .header(AUTHORIZATION_HEADER, credential)
                    .build();
        };

        var client = new OkHttpClient.Builder()
                .authenticator(authenticator)
                .readTimeout(180, TimeUnit.SECONDS)
                .build();

        var mediaType = MediaType.parse("application/json; charset=utf-8");
        var body = RequestBody.create(jsonObject.toString(), mediaType);
        var request = new Request.Builder()
                .url("https://realtime.oxylabs.io/v1/queries")
                .post(body)
                .build();

        try (var response = client.newCall(request).execute()) {
            if (response.body() != null) {
                try (var responseBody = response.body()) {
                    System.out.println(responseBody.string());
                }
            }
        } catch (Exception exception) {
            System.out.println("Error: " + exception.getMessage());
        }

        System.exit(0);
    }

    public static void main(String[] args) {
        new Thread(new Main()).start();
    }
}

Nossos exemplos usam o método de integração síncrono Realtime de. Se você quiser usar Proxy Endpoint, ou assíncrono Push-Pull consulte os Métodos de Integração da seção.

Amostra de saída

{
    "results": [
        {
            "content": "window.google.ac.h([\"what is\",[[\"what is love\",0,[512,433]],[\"what is this feeling wicked\",0,[512,433,131]],[\"what is love baby dont hurt me no\",0,[512,433]],[\"what is 67\",0,[512,433,131]],[\"what is\",0,[512]],[\"what is you nba youngboy\",0,[512,433,131]],[\"what is love haddaway\",0,[512,433]],[\"what is this feeling wicked karaoke\",0,[512,433]],[\"what is love twice\",0,[512,433,131]],[\"what is you\",0,[512,433,131,650]],[\"what is sounds like\",0,[512,433]],[\"what is scientology\",0,[512]],[\"what is the big beautiful bill\",0,[512]],[\"what is a woman\",0,[512,433]]],{\"j\":\"5\",\"k\":1,\"q\":\"fxuDygqjaW7TVwu4-jEjTrWp6b8\"}])",
            "type": "raw",
            ...
}

Valores dos parâmetros da requisição

Parâmetro

Descrição

Valor Padrão

source

Define o scraper.

youtube_autocomplete

query

O termo de pesquisa para o qual as sugestões de palavras-chave devem ser retornadas.

–

localização

Local de pesquisa (código do país com 2 letras).

US

idioma

Código do idioma de pesquisa.

en

callback_url

URL para o seu endpoint de callback. Mais info.

–

– parâmetro obrigatório

Localização

Para localização e idioma valores de parâmetro disponíveis, consulte as tabelas abaixo.

Localizações disponíveis para youtube_autocomplete

Valor do parâmetro

País

Afeganistão

Albânia

Argélia

como

Samoa Americana

Andorra

Angola

Anguilla

Antártica

Antígua e Barbuda

Argentina

Armênia

Aruba

Austrália

Áustria

Azerbaijão

Bahamas

Bahrein

Bangladesh

Barbados

Bielorrússia

Bélgica

Belize

Benim

Bermudas

Butão

Bolívia

Bósnia e Herzegovina

Botswana

Ilha Bouvet

Brasil

Território Britânico do Oceano Índico

Brunei Darussalam

Bulgária

Burquina Faso

Burundi

Camboja

Camarões

Canadá

Cabo Verde

Ilhas Cayman

República Centro-Africana

Chade

Chile

China

Ilha Christmas

Ilhas Cocos (Keeling)

Colômbia

Comores

Congo

Congo, República Democrática do

Ilhas Cook

Costa Rica

Costa do Marfim

Croácia

Cuba

Chipre

República Tcheca

Dinamarca

Djibuti

Dominica

República Dominicana

Equador

Egito

El Salvador

Guiné Equatorial

Eritreia

Estônia

Etiópia

Ilhas Malvinas (Falkland)

Ilhas Faroe

Fiji

Finlândia

França

Guiana Francesa

Polinésia Francesa

Territórios Franceses do Sul

Gabão

Gâmbia

Geórgia

Alemanha

Gana

Gibraltar

Grécia

Groenlândia

Granada

Guadalupe

Guam

Guatemala

Guiné

Guiné-Bissau

Guiana

Haiti

Ilha Heard e Ilhas McDonald

Santa Sé (Estado da Cidade do Vaticano)

Honduras

Hong Kong

Hungria

Islândia

Índia

Indonésia

Irã, República Islâmica do

Iraque

Irlanda

Israel

Itália

Jamaica

Japão

Jordânia

Cazaquistão

Quênia

Kiribati

Coreia do Norte

Coreia do Sul

Kuwait

Quirguistão

República Democrática Popular Lao

Letônia

Líbano

Lesoto

Libéria

Líbia

Liechtenstein

Lituânia

Luxemburgo

Macao

Macedônia do Norte

Madagascar

Malawi

Malásia

Maldivas

Mali

Malta

Ilhas Marshall

Martinica

Mauritânia

Maurício

Mayotte

México

Micronésia, Estados Federados da

Moldávia, República da

Mônaco

Mongólia

Montserrat

Marrocos

Moçambique

Myanmar

Namíbia

Nauru

Nepal

Países Baixos

Nova Caledônia

Nova Zelândia

Nicarágua

Níger

Nigéria

Niue

Ilha Norfolk

Ilhas Marianas do Norte

Noruega

Omã

Paquistão

Palau

Território Palestino, Ocupado

Panamá

Papua Nova Guiné

Paraguai

Peru

Filipinas

Pitcairn

Polônia

Portugal

Porto Rico

Catar

Reunião

Romênia

Federação Russa

Ruanda

Santa Helena

São Cristóvão e Nevis

Santa Lúcia

São Pedro e Miquelon

São Vicente e Granadinas

Samoa

San Marino

São Tomé e Príncipe

Arábia Saudita

Senegal

Sérvia e Montenegro

Seychelles

Serra Leoa

Singapura

Eslováquia

Eslovênia

Ilhas Salomão

Somália

África do Sul

Geórgia do Sul e Ilhas Sandwich do Sul

Espanha

Sri Lanka

Sudão

Suriname

Svalbard e Jan Mayen

Suazilândia

Suécia

Suíça

República Árabe Síria

Taiwan

Tajiquistão

Tanzânia, República Unida da

Tailândia

Timor-Leste

Togo

Tokelau

Tonga

Trinidad e Tobago

Tunísia

Turquia

Turcomenistão

Ilhas Turks e Caicos

Tuvalu

Uganda

Ucrânia

Emirados Árabes Unidos

Reino Unido

Estados Unidos

Ilhas Menores Distantes dos Estados Unidos

Uruguai

Uzbequistão

Vanuatu

Venezuela

Vietnã

Ilhas Virgens Britânicas

Ilhas Virgens dos EUA

Wallis e Futuna

Saara Ocidental

Iêmen

Zâmbia

Zimbábue

Guernsey

Jersey

Ilha de Man

Montenegro

Idiomas disponíveis para youtube_autocomplete

Valor do parâmetro

Idioma

ach

Luo

Africâner

Akan

Amárico

Árabe

Azeri

Bielo-russo

bem

Bemba

Búlgaro

Bihari

Bengali

Bretão

Bósnio

Butanês

Catalão

chr

Cherokee

ckb

Curdo (Soranî)

Corso

crs

Crioulo das Seychelles

Tcheco

Galês

Dinamarquês

Alemão

Ewe

Grego

Inglês

Esperanto

Espanhol

es-419

Espanhol (América Latina)

Estoniano

Basco

Persa

Finlandês

Faroês

Francês

Frísio

Irlandês

gaa

Gaélico Escocês

Galego

Guarani

Gujarati

Hauçá

haw

Havaiano

Hebraico

Hindi

Croata

Crioulo Haitiano

Húngaro

Armênio

Interlíngua

Indonésio

Igbo

Islandês

Italiano

Hebraico

Japonês

Javanês

Georgiano

Kongo

Cazaque

Groenlandês

Cambojano

Canarês

Coreano

kri

Krio (Serra Leoa)

Curdô

Quirguiz

Latim

Luganda

Lingala

Laosiano

loz

Lozi

Lituano

lua

Tshiluba

Letão

mfe

Crioulo Mauriciano

Malgaxe

Maori

Macedônio

Malayalam

Mongol

Moldavo

Marata

Malaio

Maltês

Maldivas

Myanmar

Nepalês

Holandês

Norueguês (Nynorsk)

Norueguês

nso

Sotho do Norte

Chichewa

nyn

Runyakitara

Occitano

Oromo

Oriá

Punjabi

pcm

Pidgin Nigeriano

Polonês

Pashto

Português

pt-br

Português (Brasil)

pt-pt

Português (Portugal)

Quíchua

Reto-romanche

Kirundi

Romeno

Russo

Kinyarwanda

Sindhi

Sérvio-Croata

Cingalês

Eslovaco

Esloveno

Shona

Somali

Albanês

Sérvio

sr-me

Montenegrino

Sotho

Sundanês

Sueco

Suaíli

Tâmil

Telugu

Tajique

Tailandês

Tigrínia

Turcomeno

Filipino

Setswana

Tonga

Turco

Tártaro

tum

Tumbuka

Twi

Uigur

Ucraniano

Urdu

Uzbeque

Vietnamita

Vanuatu

Wolof

Samoa

Xhosa

Iídiche

Iorubá

zh-cn

Chinês (Simplificado)

zh-tw

Chinês (Tradicional)

Zulu

AnteriorCanal do YouTube PróximoTarget genérico

Atualizado há 3 meses

Isto foi útil?

Boa tarde

hashtagAmostras de requisição

hashtagAmostra de saída

hashtagValores dos parâmetros da requisição

hashtagLocalização

Amostras de requisição

Amostra de saída

Valores dos parâmetros da requisição

Localização