youtubei 0.1.0

A Rust wrapper for YouTube's InnerTube API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::{youtube, InnerTubeRequestFields, YouTubeError};
use hyper_tls::HttpsConnector;
use hyper_util::client::legacy::Client;
use hyper_util::client::legacy::connect::HttpConnector;
use hyper::body::Bytes;
use http_body_util::{BodyExt, Full};
use hyper::{Method, Request, StatusCode};
use prost::Message;
use serde::{Deserialize, Serialize};

// JSON response structures for search_public_creator_entities
#[derive(Deserialize, Debug)]
struct SearchCreatorEntitiesResponse {
    channels: Vec<SearchCreatorChannel>,
}

#[derive(Deserialize, Debug)]
struct SearchCreatorChannel {
    #[serde(rename = "channelId")]
    channel_id: String,
}

pub struct SearchPublicCreatorEntitiesRequest<'a> {
    pub client: &'a mut Client<HttpsConnector<HttpConnector>, Full<Bytes>>,
    pub ip: &'a str,
    pub fields: InnerTubeRequestFields<'a>,
    pub query: String,
}

impl<'a> AsMut<InnerTubeRequestFields<'a>> for SearchPublicCreatorEntitiesRequest<'a> {
    fn as_mut(&mut self) -> &mut InnerTubeRequestFields<'a> {
        &mut self.fields
    }
}

impl<'a> SearchPublicCreatorEntitiesRequest<'a> {
    pub async fn send(self) -> Result<Vec<String>, YouTubeError> {
        let request = youtube::SearchPublicCreatorEntitiesRequest {
            context: Some(youtube::Context {
                client: Some(youtube::Client { 
                    client_name: 62, 
                    client_version: "1.20250527.06.00".to_string() 
                })
            }),
            query: self.query,
            filter: Some(crate::youtube::search_public_creator_entities_request::Filter{
                restrict_result_type: 10
            }),
            channel_mask: None,
        };

        let mut payload = Vec::new();
        request.encode(&mut payload).map_err(|e| YouTubeError::Other(Box::new(e)))?;

        let mut req_builder = Request::builder()
            .method(Method::POST)
            .uri(format!("https://{}/youtubei/v1/creator/search_public_creator_entities?alt=json", self.ip))
            .header("Host", "studio.youtube.com")
            .header("Content-Type", "application/x-protobuf")
            .header("Origin", "https://studio.youtube.com")
            .header("X-Goog-Fieldmask", "channels(channelId)");

        // Add bearer token if provided
        if let Some(token) = self.fields.authorization {
            req_builder = req_builder.header("Authorization", token);
        }

        // Add cookie if provided
        if let Some(cookie) = self.fields.cookie {
            req_builder = req_builder.header("Cookie", cookie);
        }

        let req = req_builder
            .body(Full::new(Bytes::from(payload)))
            .map_err(|e| YouTubeError::Other(Box::new(e)))?;

        let resp = self.client.request(req).await?;

        let status = resp.status();
        match status {
            StatusCode::NOT_FOUND => return Err(YouTubeError::NotFound),
            StatusCode::TOO_MANY_REQUESTS => return Err(YouTubeError::Ratelimited),
            StatusCode::UNAUTHORIZED => return Err(YouTubeError::Unauthorized),
            StatusCode::INTERNAL_SERVER_ERROR => return Err(YouTubeError::InternalServerError),
            StatusCode::OK => (), // Continue processing
            _ => {
                // For unknown status codes, collect and print the response for debugging
                let body_bytes = resp.into_body().collect().await?.to_bytes();
                let body_str = std::str::from_utf8(&body_bytes).unwrap_or("<invalid utf8>");
                println!("Unknown status code {} with response: {}", status, body_str);
                return Err(YouTubeError::UnknownStatusCode(status));
            }
        };

        let body_bytes = resp.into_body().collect().await?.to_bytes();
        
        // Parse as JSON instead of protobuf
        let body_str = std::str::from_utf8(&body_bytes)
            .map_err(|e| YouTubeError::ParseError(format!("Invalid UTF-8: {}", e)))?;

        // Handle empty response case where API returns just "{}"
        if body_str.trim() == "{}" {
            return Ok(Vec::new());
        }
            
        let response: SearchCreatorEntitiesResponse = serde_json::from_str(body_str)
            .map_err(|e| YouTubeError::ParseError(format!("JSON parse error: {}", e)))?;

        // Extract channel IDs from response
        let channel_ids: Vec<String> = response.channels
            .into_iter()
            .map(|channel| channel.channel_id[2..].to_string())
            .collect();

        Ok(channel_ids)
    }
}