Busca

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

Você pode pesquisar no YouTube por vídeos, canais, playlists ou filmes fornecendo uma consulta de busca para a youtube_search ou youtube_search_max fonte.

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

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

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

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

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

# Get response.
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('user', 'pass1'),
    json=payload,
)

# Print the JSON response with the result.
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"

	// Define the payload with the new youtube_metadata query.
	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() {
        // Construct JSON payload for youtube_metadata request
        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íncrona Realtime em nossos exemplos. Se você quiser usar Push-Pull integração, consulte a seção de métodos de integração .

848KB

youtube search output sample.json

Abrir

Parâmetros da consulta

Parâmetro

Descrição

Valor padrão

Tipo

source

Define o scraper.

youtube_search ou youtube_search_max

Cadeia de caracteres

busca

Termo de busca.

Cadeia de caracteres

- parâmetro obrigatório

Filtros

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

Parâmetros de consulta dos 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.

Cadeia de caracteres

type

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

Cadeia de caracteres

duration

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

Cadeia de caracteres

sort_by

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

relevance

Cadeia de caracteres

360

Retorna vídeos em 360 graus nos resultados da busca.

Booleano

3d

Retorna vídeos em 3D nos resultados da busca.

Booleano

4k

Retorna vídeos em resolução 4K nos resultados da busca.

Booleano

creative_commons

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

Booleano

hd

Retorna vídeos em alta definição nos resultados da busca.

Booleano

hdr

Retorna vídeos em HDR (High Dynamic Range) nos resultados da busca.

Booleano

live

Retorna transmissões ao vivo nos resultados da busca.

Booleano

location

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

Booleano

purchased

Retorna conteúdo comprado nos resultados da busca.

Booleano

subtitles

Retorna vídeos com legendas ou legendas ocultas.

Booleano

vr180

Retorna vídeos no formato VR180 nos resultados da busca.

Booleano

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

Atualizado há 25 dias

Isto foi útil?