Pesquisa no YouTube

Saiba como obter dados de busca do YouTube para vídeos, canais e playlists usando a Web Scraper API. Saiba mais sobre seus parâmetros e veja um exemplo de requisição.

Você pode pesquisar no YouTube por vídeos, canais, playlists ou filmes fornecendo uma pesquisa query para o youtube_search ou youtube_search_max source.

Oyoutube_search a fonte permite recuperar até 20 resultados de pesquisa, enquanto a youtube_search_max fonte pode retornar até 700 resultados em uma única resposta.

Esta fonte também pode ser combinada com youtube_autocomplete fonte para incluir sugestões e direcionar palavras-chave relevantes e termos de pesquisa.

Os exemplos a seguir demonstram como utilizar a youtube_search fonte para recuperar vídeos do YouTube com base em uma consulta de pesquisa.

curl 'https://realtime.oxylabs.io/v1/queries' \
--user 'USERNAME:PASSWORD' \
-H 'Content-Type: application/json' \
-d '{
        "source": "youtube_search",
        "query": "how to make a website"
    }'

import requests
from pprint import pprint

# Estruturar payload.
payload = {
    'source': 'youtube_search',
    'query': 'how to make a website'
}

# Obter resposta.
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('user', 'pass1'),
    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_search",
  query: "how to make a website"
};
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_search',
    'query' => 'how to make a website'
);
   
$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 com a nova query youtube_metadata.
	payload := map[string]interface{}{
		"source": "youtube_search",
		"query":  "how to make a website
	}

	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.Collections.Generic;
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_search",
                query = "how to make a website",
                context = new[]
                {
                    new { key = "language_code", value = "en" },
                    new { key = "transcript_origin", value = "uploader_provided" }
                }
            };

            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.JSONArray;
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() {
        // Construa o payload JSON para a requisição youtube_metadata
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("source", "youtube_search");
        jsonObject.put("query", "how to make a website");

        JSONArray contextArray = new JSONArray();
        contextArray.put(new JSONObject().put("key", "language_code").put("value", "en"));
        contextArray.put(new JSONObject().put("key", "transcript_origin").put("value", "uploader_provided"));

        jsonObject.put("context", contextArray);

        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();
    }
}

Usamos o método de integração síncrono Realtime em nossos exemplos. Se você quiser usar o Push-Pull consulte os Métodos de Integração da seção.

848KB

youtube search output sample.json

Abrir

Parâmetros de consulta

Parâmetro

Descrição

Valor Padrão

Tipo

source

Define o scraper.

youtube_search ou youtube_search_max

String

query

Termo de pesquisa.

String

- parâmetro obrigatório

Filtros

Você pode personalizar sua pesquisa usando todos os filtros disponíveis via interface do YouTube.

Parâmetros de consulta de filtros

Parâmetro

Descrição

Valor Padrão

Tipo

upload_date

Filtra vídeos pela data de envio. Valores disponíveis são: today, last_hour, this_week, this_month, this_year.

String

type

Retorna resultados por tipo de conteúdo. Valores disponíveis são: video, channel, playlist, movie.

String

duração

Duração do conteúdo em minutos. Valores disponíveis são: <4, 4-20, >20.

String

sort_by

Determina como os resultados de pesquisa são ordenados. Valores disponíveis são rating, relevance, view_count,upload_date.

relevance

String

360

Retorna vídeos em 360 graus nos resultados de pesquisa.

Booleano

3d

Retorna vídeos 3D nos resultados de pesquisa.

Booleano

4k

Retorna vídeos em resolução 4K nos resultados de pesquisa.

Booleano

creative_commons

Retorna apenas vídeos com licenças Creative Commons.

Booleano

hd

Retorna vídeos em alta definição nos resultados de pesquisa.

Booleano

hdr

Retorna vídeos HDR (High Dynamic Range) nos resultados de pesquisa.

Booleano

live

Retorna transmissões ao vivo nos resultados de pesquisa.

Booleano

localização

Retorna vídeos com informações de localização.

Booleano

purchased

Retorna conteúdo comprado nos resultados de pesquisa.

Booleano

legendas

Retorna vídeos com legendas ou closed captions.

Booleano

vr180

Retorna vídeos no formato VR180 nos resultados de pesquisa.

Booleano

AnteriorGuia de scraping do YouTube para IA PróximoTreinabilidade de vídeo do YouTube

Atualizado há 1 mês

Isto foi útil?

Boa tarde

hashtagParâmetros de consulta

hashtagFiltros

hashtagParâmetros de consulta de filtros

Parâmetros de consulta

Filtros

Parâmetros de consulta de filtros