Autocompletar de YouTube

Aprende a obtener sugerencias de términos de búsqueda de YouTube usando Web Scraper API. Conoce sus parámetros y mira una solicitud de ejemplo.

Con el youtube_autocomplete source, los usuarios pueden obtener sugerencias de palabras clave relacionadas para cualquier término de búsqueda de su elección. Estas sugerencias se pueden usar con el youtube_search source para descubrir vídeos más relevantes y ampliar sus flujos de trabajo de datos de YouTube.

Solicitar ejemplos

Los siguientes ejemplos muestran cómo recuperar sugerencias de términos de búsqueda para una 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

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

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

# Imprime la respuesta JSON con el 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();

<?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"

	// Definir la carga útil
	payload := map[string]interface{}{
		"source":   "youtube_autocomplete",
		"query":    "what is",
		"language": "en",
		"location": "US",
	}

	jsonValue, err := json.Marshal(payload)
	if err != nil {
		fmt.Println("Error marshalling 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("Error creating request:", err)
		return
	}

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

	response, err := client.Do(request)
	if err != nil {
		fmt.Println("Error making request:", err)
		return
	}
	defer response.Body.Close()

	responseText, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println("Error reading response:", 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($"Request error: {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 la carga 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();
    }
}

Nuestros ejemplos usan el método de integración síncrono Realtime Si desea usar Proxy Endpoint, o asíncrono Push-Pull para la integración, consulte los Métodos de integración sección.

Ejemplo de salida

{
    "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 de parámetros de la solicitud

Parámetro

Descripción

Valor predeterminado

source

Establece el scraper.

youtube_autocomplete

query

El término de búsqueda para el que se deben devolver sugerencias de palabras clave.

–

ubicación

Ubicación de búsqueda (código de país de 2 letras).

US

idioma

Código de idioma de búsqueda.

en

callback_url

URL de su endpoint de callback. Más información.

–

– parámetro obligatorio

Localización

Para los disponibles ubicación y idioma valores de parámetro, consulte las tablas a continuación.

Ubicaciones disponibles para youtube_autocomplete

Valor del parámetro

País

Afganistán

Albania

Argelia

como

Samoa Americana

Andorra

Angola

Anguila

Antártida

Antigua y Barbuda

Argentina

Armenia

Aruba

Australia

Austria

Azerbaiyán

Bahamas

Baréin

Bangladesh

Barbados

Bielorrusia

Bélgica

Belice

Benín

Bermudas

Bután

Bolivia

Bosnia y Herzegovina

Botsuana

Isla Bouvet

Brasil

Territorio Británico del Océano Índico

Brunéi Darussalam

Bulgaria

Burkina Faso

Burundi

Camboya

Camerún

Canadá

Cabo Verde

Islas Caimán

República Centroafricana

Chad

Chile

China

Isla Christmas

Islas Cocos (Keeling)

Colombia

Comoras

Congo

Congo, República Democrática del

Islas Cook

Costa Rica

Côte d'Ivoire

Croacia

Cuba

Chipre

República Checa

Dinamarca

Yibuti

Dominica

República Dominicana

Ecuador

Egipto

El Salvador

Guinea Ecuatorial

Eritrea

Estonia

Etiopía

Islas Malvinas (Falkland Islands)

Islas Faroe

Fiyi

Finlandia

Francia

Guayana Francesa

Polinesia Francesa

Territorios Australes Franceses

Gabón

Gambia

Georgia

Alemania

Ghana

Gibraltar

Grecia

Groenlandia

Granada

Guadalupe

Guam

Guatemala

Guinea

Guinea-Bisáu

Guyana

Haití

Isla Heard y Islas McDonald

Santa Sede (Estado de la Ciudad del Vaticano)

Honduras

Hong Kong

Hungría

Islandia

India

Indonesia

Irán, República Islámica de

Irak

Irlanda

Israel

Italia

Jamaica

Japón

Jordania

Kazajistán

Kenia

Kiribati

Corea del Norte

Corea del Sur

Kuwait

Kirguistán

República Democrática Popular Lao

Letonia

Líbano

Lesoto

Liberia

Libia

Liechtenstein

Lituania

Luxemburgo

Macao

Macedonia del Norte

Madagascar

Malawi

Malasia

Maldivas

Malí

Malta

Islas Marshall

Martinica

Mauritania

Mauricio

Mayotte

México

Micronesia, Estados Federados de

Moldavia, República de

Mónaco

Mongolia

Montserrat

Marruecos

Mozambique

Myanmar

Namibia

Nauru

Nepal

Países Bajos

Nueva Caledonia

Nueva Zelanda

Nicaragua

Níger

Nigeria

Niue

Isla Norfolk

Islas Marianas del Norte

Noruega

Omán

Pakistán

Palaos

Territorio Palestino Ocupado

Panamá

Papúa Nueva Guinea

Paraguay

Perú

Filipinas

Pitcairn

Polonia

Portugal

Puerto Rico

Catar

Reunión

Rumanía

Federación Rusa

Ruanda

Santa Helena

San Cristóbal y Nieves

Santa Lucía

San Pedro y Miquelón

San Vicente y las Granadinas

Samoa

San Marino

Santo Tomé y Príncipe

Arabia Saudita

Senegal

Serbia y Montenegro

Seychelles

Sierra Leona

Singapur

Eslovaquia

Eslovenia

Islas Salomón

Somalia

Sudáfrica

Islas Georgias del Sur y Sandwich del Sur

España

Sri Lanka

Sudán

Surinam

Svalbard y Jan Mayen

Suazilandia

Suecia

Suiza

República Árabe Siria

Taiwán

Tayikistán

Tanzania, República Unida de

Tailandia

Timor-Leste

Togo

Tokelau

Tonga

Trinidad y Tobago

Túnez

Turquía

Turkmenistán

Islas Turcas y Caicos

Tuvalu

Uganda

Ucrania

Emiratos Árabes Unidos

Reino Unido

Estados Unidos

Islas Ultramarinas Menores de Estados Unidos

Uruguay

Uzbekistán

Vanuatu

Venezuela

Viet Nam

Islas Vírgenes Británicas

Islas Vírgenes de EE. UU.

Wallis y Futuna

Sahara Occidental

Yemen

Zambia

Zimbabue

Guernsey

Jersey

Isla de Man

Montenegro

Idiomas disponibles para youtube_autocomplete

Valor del parámetro

Idioma

ach

Luo

Afrikáans

Akan

Amárico

Árabe

Azerbaiyano

Bielorruso

bem

Bemba

Búlgaro

Bihari

Bengalí

Bretón

Bosnio

Butanés

Catalán

chr

Cherokee

ckb

Curdo (Soranî)

Corso

crs

Criollo seychelense

Checo

Galés

Danés

Alemán

Ewe

Griego

Inglés

Esperanto

Español

es-419

Español (Latinoamericano)

Estonio

Euskera

Persa

Finlandés

Feroés

Francés

Frisio

Irlandés

gaa

Gaélico escocés

Gallego

Guaraní

Gujarati

Hausa

haw

Hawaiano

Hebreo

Hindi

Croata

Criollo haitiano

Húngaro

Armenio

Interlingua

Indonesia

Igbo

Islandés

Italiano

Hebreo

Japonés

Javanés

Georgiano

Kongo

Kazajo

Groenlandés

Camboyano

Kannada

Coreano

kri

Krio (Sierra Leona)

Kurdo

Kirguís

Latín

Luganda

Lingala

Laosiano

loz

Lozi

Lituano

lua

Tshiluba

Letón

mfe

Criollo mauriciano

Malagasy

Maorí

Macedonio

Malayalam

Mongol

Moldavo

Maratí

Malayo

Maltés

Maldivas

Myanmar

Nepalí

Neerlandés

Noruego (Nynorsk)

Noruego

nso

Sotho septentrional

Chichewa

nyn

Runyakitara

Occitano

Oromo

Oriya

Punjabi

pcm

Pidgin nigeriano

Polaco

Pastún

Portugués

pt-br

Portugués (Brasil)

pt-pt

Portugués (Portugal)

Quechua

Romanche

Kirundi

Rumano

Ruso

Kinyarwanda

Sindhi

Serbo-croata

Cingalés

Eslovaco

Esloveno

Shona

Somalí

Albanés

Serbio

sr-me

Montenegrino

Sesotho

Sundanés

Sueco

Swahili

Tamil

Telugú

Tayiko

Tailandés

Tigriña

Turcomano

Filipino

Setswana

Tonga

Turco

Tártaro

tum

Tumbuka

Twi

Uigur

Ucraniano

Urdu

Uzbeko

Vietnamita

Vanuatu

Wolof

Samoa

Xhosa

Yidis

Yoruba

zh-cn

Chino (simplificado)

zh-tw

Chino (tradicional)

Zulú

AnteriorCanal de YouTube SiguienteObjetivo genérico

Última actualización hace 3 meses

¿Te fue útil?

Buenas tardes

hashtagSolicitar ejemplos

hashtagEjemplo de salida

hashtagValores de parámetros de la solicitud

hashtagLocalización

Solicitar ejemplos

Ejemplo de salida

Valores de parámetros de la solicitud

Localización