Pesquisa

Raspe resultados de pesquisa do YouTube por 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 mais.

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

Oyoutube_search fonte permite recuperar até 20 resultados de busca, 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 busca relevantes.

Os exemplos a seguir demonstram como utilizar youtube_search fonte para recuperar vídeos do YouTube com base em uma busca 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

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

# Obtenha a 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 consulta 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 a 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 a requisição:", err)
		return
	}
	defer response.Body.Close()

	responseText, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println("Erro ao ler a 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 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íncrona em nossos exemplos. Se você quiser usar Push-Pull , consulte a seção métodos de integraçã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 busca.

String

- 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

data de envio

Filtra vídeos pela data de envio. Os valores disponíveis são: hoje, última hora, esta semana, este mês, este ano.

String

type

Retorna resultados por tipo de conteúdo. Os valores disponíveis são: vídeo, canal, playlist, filme.

String

duração

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 busca são ordenados. Os valores disponíveis são rating, relevância, contagem de visualizações,data de envio.

relevância

String

360

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

Booleano

3d

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

Booleano

4k

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

Booleano

creative_commons

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

Booleano

hd

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

Booleano

hdr

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

Booleano

live

Retorna transmissões ao vivo nos resultados de busca.

Booleano

location

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

Booleano

purchased

Retorna conteúdo comprado nos resultados de busca.

Booleano

legendas

Retorna vídeos com legendas ou closed captions.

Booleano

vr180

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

Booleano

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

Atualizado há 25 dias

Isto foi útil?