Pesquisa

Raspe resultados de busca do YouTube para vídeos, canais, playlists e filmes, com filtros para data de upload, duração, tipo de conteúdo, resolução, transmissões ao vivo, legendas e mais.

Você pode pesquisar no YouTube por vídeos, canais, listas de reprodução ou filmes fornecendo uma consulta para o youtube_search ou youtube_search_max fonte.

Ayoutube_search 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 e termos de pesquisa relevantes.

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,
)

# Imprimir 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("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.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($"Request error: {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() {
        // Construir payload JSON para a solicitaçã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 Realtime síncrono em nossos exemplos. Se você quiser usar a integração Push-Pull, consulte a seção Integration Methods .

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

consulta

Termo de pesquisa.

String

- parâmetro obrigatório

Filtros

Você pode personalizar sua pesquisa usando todos os filtros disponíveis via a 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. Os valores disponíveis são: today, last_hour, this_week, this_month, this_year.

String

type

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

String

duration

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

String

sort_by

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

relevance

String

360

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

Boolean

3d

Retorna vídeos em 3D nos resultados de pesquisa.

Boolean

4k

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

Boolean

creative_commons

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

Boolean

hd

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

Boolean

hdr

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

Boolean

live

Retorna transmissões ao vivo nos resultados de pesquisa.

Boolean

location

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

Boolean

purchased

Retorna conteúdo comprado nos resultados de pesquisa.

Boolean

subtitles

Retorna vídeos com legendas ou closed captions.

Boolean

vr180

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

Boolean

AnteriorGuia de Scraping para IA PróximoTreinabilidade de Vídeo

Atualizado há 1 dia

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