data-for-seo 0.2.0

Client library for the DataForSEO API v3 (SERP, Keywords Data, Labs, Backlinks, OnPage, and more)
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::DataForSeoApiResponse;
use crate::DataForSeoClient;
use crate::api::keywords_data::KeywordsDataApi;
use crate::entity::{
    KeywordsDataApiClickstreamBulkSearchVolume, KeywordsDataApiClickstreamGlobalSearchVolume,
    KeywordsDataApiClickstreamLocation, KeywordsDataApiClickstreamSearchVolume,
};
use serde::{Deserialize, Serialize};

impl KeywordsDataApi<'_> {
    /// Clickstream Data endpoints (clickstream-based search volume).
    /// See <https://docs.dataforseo.com/v3/keywords_data/clickstream_data/overview/>.
    pub fn clickstream_data(&self) -> KeywordsDataApiClickstream<'_> {
        KeywordsDataApiClickstream {
            client: self.client,
        }
    }
}

/// Clickstream Data endpoints.
pub struct KeywordsDataApiClickstream<'a> {
    pub(crate) client: &'a DataForSeoClient,
}

impl KeywordsDataApiClickstream<'_> {
    /// Locations and their available languages for Clickstream Data.
    /// See <https://docs.dataforseo.com/v3/keywords_data/clickstream_data/locations_and_languages/>.
    pub async fn locations_and_languages(
        &self,
    ) -> DataForSeoApiResponse<KeywordsDataApiClickstreamLocation> {
        self.client
            .http_get("/v3/keywords_data/clickstream_data/locations_and_languages")
            .await
    }
    /// Retrieves clickstream-based search volume synchronously.
    /// See <https://docs.dataforseo.com/v3/keywords_data/clickstream_data/dataforseo_search_volume/live/>.
    pub async fn dataforseo_search_volume_live(
        &self,
        data: Vec<KeywordsDataApiClickstreamSearchVolumeRequest>,
    ) -> DataForSeoApiResponse<KeywordsDataApiClickstreamSearchVolume> {
        self.client
            .http_post(
                "/v3/keywords_data/clickstream_data/dataforseo_search_volume/live",
                &data,
            )
            .await
    }
    /// Retrieves worldwide clickstream-based search volume synchronously.
    /// See <https://docs.dataforseo.com/v3/keywords_data/clickstream_data/global_search_volume/live/>.
    pub async fn global_search_volume_live(
        &self,
        data: Vec<KeywordsDataApiClickstreamGlobalSearchVolumeRequest>,
    ) -> DataForSeoApiResponse<KeywordsDataApiClickstreamGlobalSearchVolume> {
        self.client
            .http_post(
                "/v3/keywords_data/clickstream_data/global_search_volume/live",
                &data,
            )
            .await
    }
    /// Retrieves clickstream-based search volume for up to 1000 keywords synchronously.
    /// See <https://docs.dataforseo.com/v3/keywords_data/clickstream_data/bulk_search_volume/live/>.
    pub async fn bulk_search_volume_live(
        &self,
        data: Vec<KeywordsDataApiClickstreamBulkSearchVolumeRequest>,
    ) -> DataForSeoApiResponse<KeywordsDataApiClickstreamBulkSearchVolume> {
        self.client
            .http_post(
                "/v3/keywords_data/clickstream_data/bulk_search_volume/live",
                &data,
            )
            .await
    }
}

/// Request body for the Clickstream `dataforseo_search_volume` endpoint.
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
pub struct KeywordsDataApiClickstreamSearchVolumeRequest {
    /// Keywords to look up (up to 1000 per request).
    pub keywords: Vec<String>,
    /// Full location name; alternative to `location_code`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_name: Option<String>,
    /// Numeric location identifier; alternative to `location_name`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_code: Option<i32>,
    /// Full language name; alternative to `language_code`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language_name: Option<String>,
    /// Language code, e.g. "en"; alternative to `language_name`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language_code: Option<String>,
    /// Blend clickstream data into the returned search volume.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub use_clickstream: Option<bool>,
    /// User-defined task identifier (max 255 characters).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
}

impl KeywordsDataApiClickstreamSearchVolumeRequest {
    /// Creates a request for the given keywords.
    pub fn new(keywords: Vec<String>) -> Self {
        KeywordsDataApiClickstreamSearchVolumeRequest {
            keywords,
            ..KeywordsDataApiClickstreamSearchVolumeRequest::default()
        }
    }
}

/// Request body for the Clickstream `global_search_volume` endpoint.
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
pub struct KeywordsDataApiClickstreamGlobalSearchVolumeRequest {
    /// Keywords to look up (up to 1000; minimum 3 characters each).
    pub keywords: Vec<String>,
    /// User-defined task identifier (max 255 characters).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
}

impl KeywordsDataApiClickstreamGlobalSearchVolumeRequest {
    /// Creates a request for the given keywords.
    pub fn new(keywords: Vec<String>) -> Self {
        KeywordsDataApiClickstreamGlobalSearchVolumeRequest {
            keywords,
            ..KeywordsDataApiClickstreamGlobalSearchVolumeRequest::default()
        }
    }
}

/// Request body for the Clickstream `bulk_search_volume` endpoint.
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
pub struct KeywordsDataApiClickstreamBulkSearchVolumeRequest {
    /// Keywords to look up (up to 1000; minimum 3 characters each).
    pub keywords: Vec<String>,
    /// Full location name; alternative to `location_code`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_name: Option<String>,
    /// Numeric location identifier; alternative to `location_name`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_code: Option<i32>,
    /// User-defined task identifier (max 255 characters).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
}

impl KeywordsDataApiClickstreamBulkSearchVolumeRequest {
    /// Creates a request for the given keywords.
    pub fn new(keywords: Vec<String>) -> Self {
        KeywordsDataApiClickstreamBulkSearchVolumeRequest {
            keywords,
            ..KeywordsDataApiClickstreamBulkSearchVolumeRequest::default()
        }
    }
}