snm-brightdata-client 0.4.0

Bright Data Wrapper Client Highly compacted Data implemented in Rust with Actix Web
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// src/client.rs - Enhanced version with improved config and error handling
use crate::{config::BrightDataConfig, error::BrightDataError};
use reqwest::Client;
use serde_json::Value;

pub struct BrightDataClient {
    config: BrightDataConfig,
    client: Client,
}

impl BrightDataClient {
    pub fn new(config: BrightDataConfig) -> Result<Self, BrightDataError> {
        // Validate configuration
        config.validate().map_err(|e| BrightDataError::ConfigError(e.to_string()))?;
        
        let client = Client::builder()
            .timeout(config.timeout)
            .build()
            .map_err(|e| BrightDataError::NetworkError(e.to_string()))?;

        Ok(Self { config, client })
    }

    /// Direct BrightData API call for basic scraping
    pub async fn get(&self, target_url: &str) -> Result<Value, BrightDataError> {
        let payload = serde_json::json!({
            "url": target_url,
            "zone": self.config.web_unlocker_zone,
            "format": "raw",
        });

        let res = self
            .client
            .post(&format!("{}/request", self.config.base_url))
            .header("Authorization", format!("Bearer {}", self.config.token))
            .json(&payload)
            .send()
            .await
            .map_err(|e| BrightDataError::Request(e))?;

        let status = res.status();
        if !status.is_success() {
            let error_text = res.text().await.unwrap_or_default();
            return Err(BrightDataError::ApiError(format!(
                "BrightData API error {}: {}",
                status.as_u16(),
                error_text
            )));
        }

        let result = res.json::<Value>().await
            .map_err(|e| BrightDataError::ParseError(e.to_string()))?;

        Ok(result)
    }

    /// Search using BrightData SERP API
    pub async fn search(&self, query: &str, engine: &str) -> Result<Value, BrightDataError> {
        let search_url = self.build_search_url(engine, query);
        
        let payload = serde_json::json!({
            "url": search_url,
            "zone": self.config.serp_zone,
            "format": "raw",
            "data_format": "markdown"
        });

        let res = self
            .client
            .post(&format!("{}/request", self.config.base_url))
            .header("Authorization", format!("Bearer {}", self.config.token))
            .json(&payload)
            .send()
            .await
            .map_err(|e| BrightDataError::Request(e))?;

        let status = res.status();
        if !status.is_success() {
            let error_text = res.text().await.unwrap_or_default();
            return Err(BrightDataError::ApiError(format!(
                "BrightData SERP API error {}: {}",
                status.as_u16(),
                error_text
            )));
        }

        let result = res.json::<Value>().await
            .map_err(|e| BrightDataError::ParseError(e.to_string()))?;

        Ok(result)
    }

    /// Take screenshot using BrightData Browser
    pub async fn screenshot(&self, url: &str, width: u32, height: u32) -> Result<Value, BrightDataError> {
        let payload = serde_json::json!({
            "url": url,
            "zone": self.config.browser_zone,
            "format": "raw",
            "data_format": "screenshot",
            "viewport": {
                "width": width,
                "height": height
            }
        });

        let res = self
            .client
            .post(&format!("{}/request", self.config.base_url))
            .header("Authorization", format!("Bearer {}", self.config.token))
            .json(&payload)
            .send()
            .await
            .map_err(|e| BrightDataError::Request(e))?;

        let status = res.status();
        if !status.is_success() {
            let error_text = res.text().await.unwrap_or_default();
            return Err(BrightDataError::ApiError(format!(
                "BrightData Browser API error {}: {}",
                status.as_u16(),
                error_text
            )));
        }

        let result = res.json::<Value>().await
            .map_err(|e| BrightDataError::ParseError(e.to_string()))?;

        Ok(result)
    }

    fn build_search_url(&self, engine: &str, query: &str) -> String {
        let encoded_query = urlencoding::encode(query);
        match engine {
            "bing" => format!("https://www.bing.com/search?q={}", encoded_query),
            "yandex" => format!("https://yandex.com/search/?text={}", encoded_query),
            "duckduckgo" => format!("https://duckduckgo.com/?q={}", encoded_query),
            _ => format!("https://www.google.com/search?q={}", encoded_query),
        }
    }
}