Make API key optional for search command

search and locations work without authentication — the SerpApi server
handles unauthenticated requests. account and archive still require a key.

- make_client accepts Option<&str>; skips api_key param when None
- search::run accepts Option<&str> for api_key
- main: resolve_api_key().ok() for search (soft failure, not die)
- locations: make_client(None) instead of make_client("")

Author: ilyazub

src/commands/account.rs

@@ -5,7 +5,7 @@ use std::collections::HashMap;
 
 /// Fetch and return the account information for the given API key.
 pub async fn run(api_key: &str) -> Result<Value, CliError> {
-    let client = make_client(api_key)?;
+    let client = make_client(Some(api_key))?;
     let result = client.account(HashMap::new()).await.map_err(network_err)?;
     check_api_error(result)
 }

src/commands/archive.rs

@@ -4,7 +4,7 @@ use serde_json::Value;
 
 /// Retrieve a previously cached search result from the SerpApi archive by its ID.
 pub async fn run(id: &str, api_key: &str) -> Result<Value, CliError> {
-    let client = make_client(api_key)?;
+    let client = make_client(Some(api_key))?;
     let result = client.search_archive(id).await.map_err(network_err)?;
     check_api_error(result)
 }

src/commands/locations.rs

@@ -7,7 +7,7 @@ use serde_json::Value;
 pub async fn run(params: Vec<Param>) -> Result<Value, CliError> {
     let params_map = params::params_to_hashmap(params);
     // Locations endpoint is public – no API key needed.
-    let client = make_client("")?;
+    let client = make_client(None)?;
     let result = client.location(params_map).await.map_err(network_err)?;
     check_api_error(result)
 }

src/commands/login.rs

@@ -34,7 +34,7 @@ pub async fn run() -> Result<(), CliError> {
         });
     }
 
-    let client = make_client(api_key)?;
+    let client = make_client(Some(api_key))?;
     let result = client.account(HashMap::new()).await.map_err(network_err)?;
 
     let result = check_api_error(result)?;

src/commands/mod.rs

@@ -20,9 +20,12 @@ pub(crate) fn network_err(e: Box<dyn std::error::Error>) -> CliError {
     }
 }
 
-/// Build a `serpapi::Client` authenticated with the given API key.
-pub fn make_client(api_key: &str) -> Result<Client, CliError> {
-    let params = HashMap::from([(API_KEY_PARAM.to_string(), api_key.to_string())]);
+/// Build a `serpapi::Client`, optionally authenticated with an API key.
+pub fn make_client(api_key: Option<&str>) -> Result<Client, CliError> {
+    let mut params = HashMap::new();
+    if let Some(key) = api_key {
+        params.insert(API_KEY_PARAM.to_string(), key.to_string());
+    }
     Client::new(params).map_err(|e: Box<dyn std::error::Error>| CliError::NetworkError {
         message: e.to_string(),
     })

src/commands/search.rs

@@ -9,7 +9,7 @@ use url::Url;
 /// Execute a SerpApi search, optionally accumulating all pages into a single result.
 pub async fn run(
     params: Vec<Param>,
-    api_key: &str,
+    api_key: Option<&str>,
     fields: Option<&str>,
     all_pages: bool,
     max_pages: Option<usize>,
@@ -29,7 +29,9 @@ pub async fn run(
     }
 
     // Ensure api_key is in the initial params map so it survives page transitions.
-    params_map.insert(API_KEY_PARAM.to_string(), api_key.to_string());
+    if let Some(key) = api_key {
+        params_map.insert(API_KEY_PARAM.to_string(), key.to_string());
+    }
 
     let client = make_client(api_key)?;
     let mut current_params = params_map;
@@ -88,7 +90,9 @@ pub async fn run(
                     break;
                 }
                 let mut next_params = parse_next_params(&url)?;
-                next_params.insert(API_KEY_PARAM.to_string(), api_key.to_string());
+                if let Some(key) = api_key {
+                    next_params.insert(API_KEY_PARAM.to_string(), key.to_string());
+                }
                 let canonical = canonical_params_key(&next_params);
                 if !seen.insert(canonical) {
                     break;

src/main.rs

@@ -70,15 +70,15 @@ async fn main() {
             all_pages,
             max_pages,
         } => {
-            let api_key = resolve_api_key().unwrap_or_else(|e| die(e));
+            let api_key = config::resolve_api_key(cli.api_key.as_deref()).ok();
             let parsed_params = params
                 .iter()
                 .map(|s| s.parse::<params::Param>())
                 .collect::<Result<Vec<_>, _>>()
                 .unwrap_or_else(|e| die(e));
             commands::search::run(
                 parsed_params,
-                &api_key,
+                api_key.as_deref(),
                 cli.fields.as_deref(),
                 all_pages,
                 max_pages,