firecrawl 4.4.0__py3-none-any.whl → 4.5.0__py3-none-any.whl

firecrawl/__init__.py

@@ -17,7 +17,7 @@ from .v1 import (
     V1ChangeTrackingOptions,
 )
 
-__version__ = "4.4.0"
+__version__ = "4.5.0"
 
 # Define the logger for the Firecrawl project
 logger: logging.Logger = logging.getLogger("firecrawl")

firecrawl/__tests__/unit/v2/methods/test_pagination.py

@@ -89,6 +89,40 @@ class TestCrawlPagination:
         assert result.next == "https://api.firecrawl.dev/v2/crawl/test-crawl-123?page=2"
         assert len(result.data) == 1
         assert isinstance(result.data[0], Document)
+
+    def test_get_crawl_status_propagates_request_timeout(self):
+        """Ensure request_timeout is forwarded to the HTTP client."""
+        mock_response = Mock()
+        mock_response.ok = True
+        mock_response.json.return_value = {
+            "success": True,
+            "status": "completed",
+            "completed": 1,
+            "total": 1,
+            "creditsUsed": 1,
+            "expiresAt": "2024-01-01T00:00:00Z",
+            "next": None,
+            "data": [self.sample_doc],
+        }
+
+        self.mock_client.get.return_value = mock_response
+
+        timeout_seconds = 5.5
+        import firecrawl.v2.methods.crawl as crawl_module
+
+        assert crawl_module.__file__.endswith("firecrawl/v2/methods/crawl.py")
+        assert crawl_module.get_crawl_status.__kwdefaults__ is not None
+        assert "request_timeout" in crawl_module.get_crawl_status.__kwdefaults__
+        result = get_crawl_status(
+            self.mock_client,
+            self.job_id,
+            request_timeout=timeout_seconds,
+        )
+
+        assert result.status == "completed"
+        self.mock_client.get.assert_called_with(
+            f"/v2/crawl/{self.job_id}", timeout=timeout_seconds
+        )
     
     def test_get_crawl_status_with_pagination(self):
         """Test get_crawl_status with auto_paginate=True."""
@@ -423,7 +457,42 @@ class TestAsyncPagination:
         assert result.next is None
         assert len(result.data) == 2
         assert self.mock_client.get.call_count == 2
-    
+
+    @pytest.mark.asyncio
+    async def test_get_crawl_status_async_propagates_request_timeout(self):
+        """Ensure async request_timeout is forwarded to the HTTP client."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "success": True,
+            "status": "completed",
+            "completed": 1,
+            "total": 1,
+            "creditsUsed": 1,
+            "expiresAt": "2024-01-01T00:00:00Z",
+            "next": None,
+            "data": [self.sample_doc],
+        }
+
+        self.mock_client.get.return_value = mock_response
+
+        timeout_seconds = 3.3
+        import firecrawl.v2.methods.aio.crawl as crawl_module_async
+
+        assert crawl_module_async.__file__.endswith("firecrawl/v2/methods/aio/crawl.py")
+        assert crawl_module_async.get_crawl_status.__kwdefaults__ is not None
+        assert "request_timeout" in crawl_module_async.get_crawl_status.__kwdefaults__
+        result = await get_crawl_status_async(
+            self.mock_client,
+            self.job_id,
+            request_timeout=timeout_seconds,
+        )
+
+        assert result.status == "completed"
+        self.mock_client.get.assert_awaited_with(
+            f"/v2/crawl/{self.job_id}", timeout=timeout_seconds
+        )
+
     @pytest.mark.asyncio
     async def test_get_batch_scrape_status_async_with_pagination(self):
         """Test async get_batch_scrape_status with pagination."""

firecrawl/v2/client.py

@@ -54,10 +54,14 @@ from .watcher import Watcher
 class FirecrawlClient:
     """
     Main Firecrawl v2 API client.
-    
+
     This client provides a clean, modular interface to all Firecrawl functionality.
     """
-    
+
+    @staticmethod
+    def _is_cloud_service(url: str) -> bool:
+        return "api.firecrawl.dev" in url.lower()
+
     def __init__(
         self,
         api_key: Optional[str] = None,
@@ -68,7 +72,7 @@ class FirecrawlClient:
     ):
         """
         Initialize the Firecrawl client.
-        
+
         Args:
             api_key: Firecrawl API key (or set FIRECRAWL_API_KEY env var)
             api_url: Base URL for the Firecrawl API
@@ -78,13 +82,13 @@ class FirecrawlClient:
         """
         if api_key is None:
             api_key = os.getenv("FIRECRAWL_API_KEY")
-        
-        if not api_key:
+
+        if self._is_cloud_service(api_url) and not api_key:
             raise ValueError(
-                "API key is required. Set FIRECRAWL_API_KEY environment variable "
+                "API key is required for the cloud API. Set FIRECRAWL_API_KEY environment variable "
                 "or pass api_key parameter."
             )
-        
+
         self.config = ClientConfig(
             api_key=api_key,
             api_url=api_url,
@@ -92,7 +96,7 @@ class FirecrawlClient:
             max_retries=max_retries,
             backoff_factor=backoff_factor
         )
-        
+
         self.http_client = HttpClient(api_key, api_url)
     
     def scrape(
@@ -236,6 +240,7 @@ class FirecrawlClient:
         zero_data_retention: bool = False,
         poll_interval: int = 2,
         timeout: Optional[int] = None,
+        request_timeout: Optional[float] = None,
         integration: Optional[str] = None,
     ) -> CrawlJob:
         """
@@ -259,7 +264,8 @@ class FirecrawlClient:
             scrape_options: Page scraping configuration
             zero_data_retention: Whether to delete data after 24 hours
             poll_interval: Seconds between status checks
-            timeout: Maximum seconds to wait (None for no timeout)
+            timeout: Maximum seconds to wait for the entire crawl job to complete (None for no timeout)
+            request_timeout: Timeout (in seconds) for each individual HTTP request, including pagination requests when fetching results. If there are multiple pages, each page request gets this timeout
             
         Returns:
             CrawlJob when job completes
@@ -290,10 +296,11 @@ class FirecrawlClient:
         )
         
         return crawl_module.crawl(
-            self.http_client, 
-            request, 
-            poll_interval=poll_interval, 
-            timeout=timeout
+            self.http_client,
+            request,
+            poll_interval=poll_interval,
+            timeout=timeout,
+            request_timeout=request_timeout,
         )
     
     def start_crawl(
@@ -368,9 +375,11 @@ class FirecrawlClient:
         return crawl_module.start_crawl(self.http_client, request)
     
     def get_crawl_status(
-        self, 
+        self,
         job_id: str,
-        pagination_config: Optional[PaginationConfig] = None
+        pagination_config: Optional[PaginationConfig] = None,
+        *,
+        request_timeout: Optional[float] = None,
     ) -> CrawlJob:
         """
         Get the status of a crawl job.
@@ -378,6 +387,9 @@ class FirecrawlClient:
         Args:
             job_id: ID of the crawl job
             pagination_config: Optional configuration for pagination behavior
+            request_timeout: Timeout (in seconds) for each individual HTTP request. When auto-pagination 
+                is enabled (default) and there are multiple pages of results, this timeout applies to 
+                each page request separately, not to the entire operation
             
         Returns:
             CrawlJob with current status and data
@@ -386,9 +398,10 @@ class FirecrawlClient:
             Exception: If the status check fails
         """
         return crawl_module.get_crawl_status(
-            self.http_client, 
+            self.http_client,
             job_id,
-            pagination_config=pagination_config
+            pagination_config=pagination_config,
+            request_timeout=request_timeout,
         )
     
     def get_crawl_errors(self, crawl_id: str) -> CrawlErrorsResponse:

firecrawl/v2/client_async.py

@@ -4,6 +4,7 @@ Async v2 client mirroring the regular client surface using true async HTTP trans
 
 import os
 import asyncio
+import time
 from typing import Optional, List, Dict, Any, Union, Callable, Literal
 from .types import (
     ScrapeOptions,
@@ -47,11 +48,15 @@ from .methods.aio import extract as async_extract  # type: ignore[attr-defined]
 from .watcher_async import AsyncWatcher
 
 class AsyncFirecrawlClient:
+    @staticmethod
+    def _is_cloud_service(url: str) -> bool:
+        return "api.firecrawl.dev" in url.lower()
+
     def __init__(self, api_key: Optional[str] = None, api_url: str = "https://api.firecrawl.dev"):
         if api_key is None:
             api_key = os.getenv("FIRECRAWL_API_KEY")
-        if not api_key:
-            raise ValueError("API key is required. Set FIRECRAWL_API_KEY or pass api_key.")
+        if self._is_cloud_service(api_url) and not api_key:
+            raise ValueError("API key is required for the cloud API. Set FIRECRAWL_API_KEY or pass api_key.")
         self.http_client = HttpClient(api_key, api_url)
         self.async_http_client = AsyncHttpClient(api_key, api_url)
 
@@ -77,33 +82,91 @@ class AsyncFirecrawlClient:
         request = CrawlRequest(url=url, **kwargs)
         return await async_crawl.start_crawl(self.async_http_client, request)
 
-    async def wait_crawl(self, job_id: str, poll_interval: int = 2, timeout: Optional[int] = None) -> CrawlJob:
-        # simple polling loop using blocking get (ok for test-level async)
-        start = asyncio.get_event_loop().time()
+    async def wait_crawl(
+        self,
+        job_id: str,
+        poll_interval: int = 2,
+        timeout: Optional[int] = None,
+        *,
+        request_timeout: Optional[float] = None,
+    ) -> CrawlJob:
+        """
+        Polls the status of a crawl job until it reaches a terminal state.
+
+        Args:
+            job_id (str): The ID of the crawl job to poll.
+            poll_interval (int, optional): Number of seconds to wait between polling attempts. Defaults to 2.
+            timeout (Optional[int], optional): Maximum number of seconds to wait for the entire crawl job to complete before timing out. If None, waits indefinitely. Defaults to None.
+            request_timeout (Optional[float], optional): Timeout (in seconds) for each individual HTTP request, including pagination requests when fetching results. If there are multiple pages, each page request gets this timeout. If None, no per-request timeout is set. Defaults to None.
+
+        Returns:
+            CrawlJob: The final status of the crawl job when it reaches a terminal state.
+
+        Raises:
+            TimeoutError: If the crawl does not reach a terminal state within the specified timeout.
+
+        Terminal states:
+            - "completed": The crawl finished successfully.
+            - "failed": The crawl finished with an error.
+            - "cancelled": The crawl was cancelled.
+        """
+        start = time.monotonic()
         while True:
-            status = await async_crawl.get_crawl_status(self.async_http_client, job_id)
-            if status.status in ["completed", "failed"]:
+            status = await async_crawl.get_crawl_status(
+                self.async_http_client,
+                job_id,
+                request_timeout=request_timeout,
+            )
+            if status.status in ["completed", "failed", "cancelled"]:
                 return status
-            if timeout and (asyncio.get_event_loop().time() - start) > timeout:
+            if timeout and (time.monotonic() - start) > timeout:
                 raise TimeoutError("Crawl wait timed out")
             await asyncio.sleep(poll_interval)
 
     async def crawl(self, **kwargs) -> CrawlJob:
         # wrapper combining start and wait
-        resp = await self.start_crawl(**{k: v for k, v in kwargs.items() if k not in ("poll_interval", "timeout")})
+        resp = await self.start_crawl(
+            **{k: v for k, v in kwargs.items() if k not in ("poll_interval", "timeout", "request_timeout")}
+        )
         poll_interval = kwargs.get("poll_interval", 2)
         timeout = kwargs.get("timeout")
-        return await self.wait_crawl(resp.id, poll_interval=poll_interval, timeout=timeout)
+        request_timeout = kwargs.get("request_timeout")
+        effective_request_timeout = request_timeout if request_timeout is not None else timeout
+        return await self.wait_crawl(
+            resp.id,
+            poll_interval=poll_interval,
+            timeout=timeout,
+            request_timeout=effective_request_timeout,
+        )
 
     async def get_crawl_status(
-        self, 
+        self,
         job_id: str,
-        pagination_config: Optional[PaginationConfig] = None
+        pagination_config: Optional[PaginationConfig] = None,
+        *,
+        request_timeout: Optional[float] = None,
     ) -> CrawlJob:
+        """
+        Get the status of a crawl job.
+        
+        Args:
+            job_id: ID of the crawl job
+            pagination_config: Optional configuration for pagination behavior
+            request_timeout: Timeout (in seconds) for each individual HTTP request. When auto-pagination 
+                is enabled (default) and there are multiple pages of results, this timeout applies to 
+                each page request separately, not to the entire operation
+            
+        Returns:
+            CrawlJob with current status and data
+            
+        Raises:
+            Exception: If the status check fails
+        """
         return await async_crawl.get_crawl_status(
-            self.async_http_client, 
+            self.async_http_client,
             job_id,
-            pagination_config=pagination_config
+            pagination_config=pagination_config,
+            request_timeout=request_timeout,
         )
 
     async def cancel_crawl(self, job_id: str) -> bool:

firecrawl/v2/methods/aio/crawl.py

@@ -87,9 +87,11 @@ async def start_crawl(client: AsyncHttpClient, request: CrawlRequest) -> CrawlRe
 
 
 async def get_crawl_status(
-    client: AsyncHttpClient, 
+    client: AsyncHttpClient,
     job_id: str,
-    pagination_config: Optional[PaginationConfig] = None
+    pagination_config: Optional[PaginationConfig] = None,
+    *,
+    request_timeout: Optional[float] = None,
 ) -> CrawlJob:
     """
     Get the status of a crawl job.
@@ -98,6 +100,9 @@ async def get_crawl_status(
         client: Async HTTP client instance
         job_id: ID of the crawl job
         pagination_config: Optional configuration for pagination limits
+        request_timeout: Timeout (in seconds) for each individual HTTP request. When auto-pagination 
+            is enabled (default) and there are multiple pages of results, this timeout applies to 
+            each page request separately, not to the entire operation
         
     Returns:
         CrawlJob with job information
@@ -105,7 +110,7 @@ async def get_crawl_status(
     Raises:
         Exception: If the status check fails
     """
-    response = await client.get(f"/v2/crawl/{job_id}")
+    response = await client.get(f"/v2/crawl/{job_id}", timeout=request_timeout)
     if response.status_code >= 400:
         handle_response_error(response, "get crawl status")
     body = response.json()
@@ -120,10 +125,11 @@ async def get_crawl_status(
         auto_paginate = pagination_config.auto_paginate if pagination_config else True
         if auto_paginate and body.get("next"):
             documents = await _fetch_all_pages_async(
-                client, 
-                body.get("next"), 
-                documents, 
-                pagination_config
+                client,
+                body.get("next"),
+                documents,
+                pagination_config,
+                request_timeout=request_timeout,
             )
         
         return CrawlJob(
@@ -142,7 +148,9 @@ async def _fetch_all_pages_async(
     client: AsyncHttpClient,
     next_url: str,
     initial_documents: List[Document],
-    pagination_config: Optional[PaginationConfig] = None
+    pagination_config: Optional[PaginationConfig] = None,
+    *,
+    request_timeout: Optional[float] = None,
 ) -> List[Document]:
     """
     Fetch all pages of crawl results asynchronously.
@@ -152,6 +160,7 @@ async def _fetch_all_pages_async(
         next_url: URL for the next page
         initial_documents: Documents from the first page
         pagination_config: Optional configuration for pagination limits
+        request_timeout: Optional timeout (in seconds) for the underlying HTTP request
         
     Returns:
         List of all documents from all pages
@@ -176,7 +185,7 @@ async def _fetch_all_pages_async(
             break
         
         # Fetch next page
-        response = await client.get(current_url)
+        response = await client.get(current_url, timeout=request_timeout)
         
         if response.status_code >= 400:
             # Log error but continue with what we have

firecrawl/v2/methods/crawl.py

@@ -142,37 +142,42 @@ def start_crawl(client: HttpClient, request: CrawlRequest) -> CrawlResponse:
 
 
 def get_crawl_status(
-    client: HttpClient, 
+    client: HttpClient,
     job_id: str,
-    pagination_config: Optional[PaginationConfig] = None
+    pagination_config: Optional[PaginationConfig] = None,
+    *,
+    request_timeout: Optional[float] = None,
 ) -> CrawlJob:
     """
     Get the status of a crawl job.
-    
+
     Args:
         client: HTTP client instance
         job_id: ID of the crawl job
         pagination_config: Optional configuration for pagination behavior
-        
+        request_timeout: Timeout (in seconds) for each individual HTTP request. When auto-pagination 
+            is enabled (default) and there are multiple pages of results, this timeout applies to 
+            each page request separately, not to the entire operation
+
     Returns:
         CrawlJob with current status and data
-        
+
     Raises:
         Exception: If the status check fails
     """
     # Make the API request
-    response = client.get(f"/v2/crawl/{job_id}")
-    
+    response = client.get(f"/v2/crawl/{job_id}", timeout=request_timeout)
+
     # Handle errors
     if not response.ok:
         handle_response_error(response, "get crawl status")
-    
+
     # Parse response
     response_data = response.json()
-    
+
     if response_data.get("success"):
         # The API returns status fields at the top level, not in a data field
-        
+
         # Convert documents
         documents = []
         data_list = response_data.get("data", [])
@@ -183,17 +188,22 @@ def get_crawl_status(
                 continue
             else:
                 documents.append(Document(**normalize_document_input(doc_data)))
-        
+
         # Handle pagination if requested
         auto_paginate = pagination_config.auto_paginate if pagination_config else True
-        if auto_paginate and response_data.get("next") and not (pagination_config and pagination_config.max_results is not None and len(documents) >= pagination_config.max_results):
+        if auto_paginate and response_data.get("next") and not (
+            pagination_config
+            and pagination_config.max_results is not None
+            and len(documents) >= pagination_config.max_results
+        ):
             documents = _fetch_all_pages(
-                client, 
-                response_data.get("next"), 
-                documents, 
-                pagination_config
+                client,
+                response_data.get("next"),
+                documents,
+                pagination_config,
+                request_timeout=request_timeout,
             )
-        
+
         # Create CrawlJob with current status and data
         return CrawlJob(
             status=response_data.get("status"),
@@ -212,31 +222,34 @@ def _fetch_all_pages(
     client: HttpClient,
     next_url: str,
     initial_documents: List[Document],
-    pagination_config: Optional[PaginationConfig] = None
+    pagination_config: Optional[PaginationConfig] = None,
+    *,
+    request_timeout: Optional[float] = None,
 ) -> List[Document]:
     """
     Fetch all pages of crawl results.
-    
+
     Args:
         client: HTTP client instance
         next_url: URL for the next page
         initial_documents: Documents from the first page
         pagination_config: Optional configuration for pagination limits
-        
+        request_timeout: Optional timeout (in seconds) for the underlying HTTP request
+
     Returns:
         List of all documents from all pages
     """
     documents = initial_documents.copy()
     current_url = next_url
     page_count = 0
-    
+
     # Apply pagination limits
     max_pages = pagination_config.max_pages if pagination_config else None
     max_results = pagination_config.max_results if pagination_config else None
     max_wait_time = pagination_config.max_wait_time if pagination_config else None
-    
+
     start_time = time.monotonic()
-    
+
     while current_url:
         # Check pagination limits (treat 0 as a valid limit)
         if (max_pages is not None) and page_count >= max_pages:
@@ -244,22 +257,22 @@ def _fetch_all_pages(
 
         if (max_wait_time is not None) and (time.monotonic() - start_time) > max_wait_time:
             break
-        
+
         # Fetch next page
-        response = client.get(current_url)
-        
+        response = client.get(current_url, timeout=request_timeout)
+
         if not response.ok:
             # Log error but continue with what we have
             import logging
             logger = logging.getLogger("firecrawl")
             logger.warning("Failed to fetch next page", extra={"status_code": response.status_code})
             break
-        
+
         page_data = response.json()
-        
+
         if not page_data.get("success"):
             break
-        
+
         # Add documents from this page
         data_list = page_data.get("data", [])
         for doc_data in data_list:
@@ -270,15 +283,15 @@ def _fetch_all_pages(
                 if max_results is not None and len(documents) >= max_results:
                     break
                 documents.append(Document(**normalize_document_input(doc_data)))
-        
+
         # Check if we hit max_results limit
         if max_results is not None and len(documents) >= max_results:
             break
-        
+
         # Get next URL
         current_url = page_data.get("next")
         page_count += 1
-    
+
     return documents
 
 
@@ -309,7 +322,9 @@ def wait_for_crawl_completion(
     client: HttpClient,
     job_id: str,
     poll_interval: int = 2,
-    timeout: Optional[int] = None
+    timeout: Optional[int] = None,
+    *,
+    request_timeout: Optional[float] = None,
 ) -> CrawlJob:
     """
     Wait for a crawl job to complete, polling for status updates.
@@ -319,6 +334,7 @@ def wait_for_crawl_completion(
         job_id: ID of the crawl job
         poll_interval: Seconds between status checks
         timeout: Maximum seconds to wait (None for no timeout)
+        request_timeout: Optional timeout (in seconds) for each status request
         
     Returns:
         CrawlJob when job completes
@@ -330,7 +346,11 @@ def wait_for_crawl_completion(
     start_time = time.monotonic()
     
     while True:
-        crawl_job = get_crawl_status(client, job_id)
+        crawl_job = get_crawl_status(
+            client,
+            job_id,
+            request_timeout=request_timeout,
+        )
         
         # Check if job is complete
         if crawl_job.status in ["completed", "failed", "cancelled"]:
@@ -348,7 +368,9 @@ def crawl(
     client: HttpClient,
     request: CrawlRequest,
     poll_interval: int = 2,
-    timeout: Optional[int] = None
+    timeout: Optional[int] = None,
+    *,
+    request_timeout: Optional[float] = None,
 ) -> CrawlJob:
     """
     Start a crawl job and wait for it to complete.
@@ -357,7 +379,9 @@ def crawl(
         client: HTTP client instance
         request: CrawlRequest containing URL and options
         poll_interval: Seconds between status checks
-        timeout: Maximum seconds to wait (None for no timeout)
+        timeout: Maximum seconds to wait for the entire crawl job to complete (None for no timeout)
+        request_timeout: Timeout (in seconds) for each individual HTTP request, including pagination 
+            requests when fetching results. If there are multiple pages, each page request gets this timeout
         
     Returns:
         CrawlJob when job completes
@@ -371,9 +395,16 @@ def crawl(
     crawl_job = start_crawl(client, request)
     job_id = crawl_job.id
     
+    # Determine the per-request timeout. If not provided, reuse the overall timeout value.
+    effective_request_timeout = request_timeout if request_timeout is not None else timeout
+
     # Wait for completion
     return wait_for_crawl_completion(
-        client, job_id, poll_interval, timeout
+        client,
+        job_id,
+        poll_interval,
+        timeout,
+        request_timeout=effective_request_timeout,
     )
 
 

firecrawl/v2/types.py

@@ -768,7 +768,7 @@ class ActiveCrawlsRequest(BaseModel):
 # Configuration types
 class ClientConfig(BaseModel):
     """Configuration for the Firecrawl client."""
-    api_key: str
+    api_key: Optional[str] = None
     api_url: str = "https://api.firecrawl.dev"
     timeout: Optional[float] = None
     max_retries: int = 3

firecrawl/v2/utils/http_client.py

@@ -12,8 +12,8 @@ version = get_version()
 
 class HttpClient:
     """HTTP client with retry logic and error handling."""
-    
-    def __init__(self, api_key: str, api_url: str):
+
+    def __init__(self, api_key: Optional[str], api_url: str):
         self.api_key = api_key
         self.api_url = api_url
 
@@ -43,8 +43,10 @@ class HttpClient:
         """Prepare headers for API requests."""
         headers = {
             'Content-Type': 'application/json',
-            'Authorization': f'Bearer {self.api_key}',
         }
+
+        if self.api_key:
+            headers['Authorization'] = f'Bearer {self.api_key}'
         
         if idempotency_key:
             headers['x-idempotency-key'] = idempotency_key

firecrawl/v2/utils/http_client_async.py

@@ -6,15 +6,19 @@ version = get_version()
 
 
 class AsyncHttpClient:
-    def __init__(self, api_key: str, api_url: str):
+    def __init__(self, api_key: Optional[str], api_url: str):
         self.api_key = api_key
         self.api_url = api_url
+        headers = {
+            "Content-Type": "application/json",
+        }
+
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
         self._client = httpx.AsyncClient(
             base_url=api_url,
-            headers={
-                "Authorization": f"Bearer {api_key}",
-                "Content-Type": "application/json",
-            },
+            headers=headers,
             limits=httpx.Limits(max_keepalive_connections=0),
         )
 

{firecrawl-4.4.0.dist-info → firecrawl-4.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firecrawl
-Version: 4.4.0
+Version: 4.5.0
 Summary: Python SDK for Firecrawl API
 Home-page: https://github.com/firecrawl/firecrawl
 Author: Mendable.ai

{firecrawl-4.4.0.dist-info → firecrawl-4.5.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-firecrawl/__init__.py,sha256=-2sr3h_Oqik7BIh0eYYKkdjWLu_tzqPIWmwCPj4bv_Q,2192
+firecrawl/__init__.py,sha256=h5JuKDOp26ACul3BYZGHNqnTW8xeuPd7kiSSPtW1tVo,2192
 firecrawl/client.py,sha256=Lmrg2jniCETU6_xVMn_fgLrgDXiBixK9hSkkdsCGiog,11840
 firecrawl/firecrawl.backup.py,sha256=v1FEN3jR4g5Aupg4xp6SLkuFvYMQuUKND2YELbYjE6c,200430
 firecrawl/types.py,sha256=RmLTq14Z-Nf883wgZxubrtn2HDu9mecsCEdcIdBCu14,2923
@@ -25,7 +25,7 @@ firecrawl/__tests__/unit/v2/methods/test_crawl_params.py,sha256=p9hzg14uAs1iHKXP
 firecrawl/__tests__/unit/v2/methods/test_crawl_request_preparation.py,sha256=PEKbooNXfQwPpvcPHXABJnveztgAA-RFBhtlSs8uPro,8780
 firecrawl/__tests__/unit/v2/methods/test_crawl_validation.py,sha256=kErOmHSD01eMjXiMd4rgsMVGd_aU2G9uVymBjbAFoGw,3918
 firecrawl/__tests__/unit/v2/methods/test_map_request_preparation.py,sha256=w4FZrDqk9XGOuCHw3SV5CkbRuyb_F4Kc8C5eJ7zVcFs,1959
-firecrawl/__tests__/unit/v2/methods/test_pagination.py,sha256=wNc9UtdauII_jzsjlJh645NBRq4IbQij1NeBwbyTjBU,22463
+firecrawl/__tests__/unit/v2/methods/test_pagination.py,sha256=-L4MLt6P_UVaQZQP9GVajxktABzqJHz7CojxuZnGjwI,24967
 firecrawl/__tests__/unit/v2/methods/test_scrape_request_preparation.py,sha256=mxx4B7v4cC42ivLUCosFB2cBIaBI7m9uOUsbE8pyyGU,4077
 firecrawl/__tests__/unit/v2/methods/test_search_request_preparation.py,sha256=HVqXDKO3602gPq-Rl0bXpfbAG5o0QBH51dgy8IOmm5s,6163
 firecrawl/__tests__/unit/v2/methods/test_search_validation.py,sha256=7UGcNHpQzCpZbAPYjthfdPFWmAPcoApY-ED-khtuANs,9498
@@ -44,13 +44,13 @@ firecrawl/__tests__/unit/v2/watcher/test_ws_watcher.py,sha256=87w47n0iOihtu4jTR4
 firecrawl/v1/__init__.py,sha256=aP1oisPeZVGGZynvENc07JySMOZfv_4zAlxQ0ecMJXA,481
 firecrawl/v1/client.py,sha256=2Rq38RxGnuf2dMCmr4cc3f-ythavcBkUyJmRrwLmMHg,208104
 firecrawl/v2/__init__.py,sha256=Jc6a8tBjYG5OPkjDM5pl-notyys-7DEj7PLEfepv3fc,137
-firecrawl/v2/client.py,sha256=KBDN8p7epuCOG0XNb-jcftxfboufgYLYl6d3RiYyORA,32828
-firecrawl/v2/client_async.py,sha256=lnVnnjwVDVYHT1a2IiBooZi4rPt75gdxpzD0WpRrvb8,11457
-firecrawl/v2/types.py,sha256=0cv39cqOyLYWV-UloJS-qTyF8jKNt13312mP8kMzRSg,26411
+firecrawl/v2/client.py,sha256=32gO-51LVD2RqPO4o-4WLHLWKQIq-mA8aAbhS8fRftA,33675
+firecrawl/v2/client_async.py,sha256=ZgCcU3Ro_3PfqJ_tilBWcRqJr7BbQVd9VIVVOcftvr4,13963
+firecrawl/v2/types.py,sha256=wQLlJ3gc-EBWI6zMr_01P3U8M02772I_prhB7JUGNYA,26428
 firecrawl/v2/watcher.py,sha256=FOU71tqSKxgeuGycu4ye0SLc2dw7clIcoQjPsi-4Csc,14229
 firecrawl/v2/watcher_async.py,sha256=dMMACMgeKrne_xSYeRvPu0m8nXqdNkDEsaiNBiD5ilw,10370
 firecrawl/v2/methods/batch.py,sha256=-eGnCGgB76pY-BFVKG1DC58XViETWukQXtDU0esU_UU,14865
-firecrawl/v2/methods/crawl.py,sha256=bNHdIrknZSSnDzctGtTSoWIJ6vSTUOTB4F_Le8Oy3RY,18810
+firecrawl/v2/methods/crawl.py,sha256=XyR88MPfF11HUOhZR3JJTQIv477ZyJ2uty286H-p5K4,20049
 firecrawl/v2/methods/extract.py,sha256=5EcgBzF8uNwA7auzco8xWdOycVV-Y44e04xJG4nlfZY,4982
 firecrawl/v2/methods/map.py,sha256=MH8jhLIFsp-4IC9womVtdCyarnGTeMqBXqwL21TRbFk,2849
 firecrawl/v2/methods/scrape.py,sha256=CSHBwC-P91UfrW3zHirjNAs2h899FKcWvd1DY_4fJdo,1921
@@ -58,7 +58,7 @@ firecrawl/v2/methods/search.py,sha256=cyHYDioLtr3QKWqFMibXEjl-JeG-UzircmEvzR2NzC
 firecrawl/v2/methods/usage.py,sha256=NqkmFd-ziw8ijbZxwaxjxZHl85u0LTe_TYqr_NGWFwE,3693
 firecrawl/v2/methods/aio/__init__.py,sha256=RocMJnGwnLIvGu3G8ZvY8INkipC7WHZiu2bE31eSyJs,35
 firecrawl/v2/methods/aio/batch.py,sha256=0R01YcWqk4Tkilbec1EH2fqY614F5PPICQmILRJg38A,6840
-firecrawl/v2/methods/aio/crawl.py,sha256=zLYmiYgwuqnussrEGyDOsej78lqQBKacg8wFKhRN0Qc,11684
+firecrawl/v2/methods/aio/crawl.py,sha256=X5P4X_kEI2-Fcm4p46I-qdUW-RomlreAQNBxztX2pfo,12244
 firecrawl/v2/methods/aio/extract.py,sha256=oc7LcjJ3g3nGYJeedEn2YWOg8X0NqgQpd0DrlI0SyiU,4516
 firecrawl/v2/methods/aio/map.py,sha256=4dIRBz6GRj_Ip6gbfFKi4ojN9nKBKEp8CXW4sdxFZaA,2551
 firecrawl/v2/methods/aio/scrape.py,sha256=ilA9qco8YGwCFpE0PN1XBQUyuHPQwH2QioZ-xsfxhgU,1386
@@ -67,14 +67,15 @@ firecrawl/v2/methods/aio/usage.py,sha256=iUzTkdAWRheq-V5rRXcW0bc3MSODaVS1AqroRF0
 firecrawl/v2/utils/__init__.py,sha256=i1GgxySmqEXpWSBQCu3iZBPIJG7fXj0QXCDWGwerWNs,338
 firecrawl/v2/utils/error_handler.py,sha256=Iuf916dHphDY8ObNNlWy75628DFeJ0Rv8ljRp4LttLE,4199
 firecrawl/v2/utils/get_version.py,sha256=0CxW_41q2hlzIxEWOivUCaYw3GFiSIH32RPUMcIgwAY,492
-firecrawl/v2/utils/http_client.py,sha256=gUrC1CvU5sj03w27Lbq-3-yH38Yi_OXiI01-piwA83w,6027
-firecrawl/v2/utils/http_client_async.py,sha256=iy89_bk2HS3afSRHZ8016eMCa9Fk-5MFTntcOHfbPgE,1936
+firecrawl/v2/utils/http_client.py,sha256=0hII3mnF_1Vd1nElu-hC9PipTUABGamUKb27q92_m5E,6068
+firecrawl/v2/utils/http_client_async.py,sha256=Mt6Dw_i2R_W81ONXnl9N_AlPiggfylOPfbD5Rpgi7tA,1991
 firecrawl/v2/utils/normalize.py,sha256=nlTU6QRghT1YKZzNZlIQj4STSRuSUGrS9cCErZIcY5w,3636
 firecrawl/v2/utils/validation.py,sha256=zzpCK4McM4P8Cag0_8s-d7Ww0idyTWKB4-yk92MT-rY,15405
-firecrawl-4.4.0.dist-info/licenses/LICENSE,sha256=nPCunEDwjRGHlmjvsiDUyIWbkqqyj3Ej84ntnh0g0zA,1084
+firecrawl-4.5.0.dist-info/licenses/LICENSE,sha256=nPCunEDwjRGHlmjvsiDUyIWbkqqyj3Ej84ntnh0g0zA,1084
+tests/test_api_key_handling.py,sha256=iNaHp6zc9bIwpN3DdiWB2Rzk0j7HCP7VgpRE_1byNYc,1303
 tests/test_change_tracking.py,sha256=_IJ5ShLcoj2fHDBaw-nE4I4lHdmDB617ocK_XMHhXps,4177
 tests/test_timeout_conversion.py,sha256=PWlIEMASQNhu4cp1OW_ebklnE9NCiigPnEFCtI5N3w0,3996
-firecrawl-4.4.0.dist-info/METADATA,sha256=koMmKCkduC_7WcdU1z0_1G0b8sKaQpBQDOYb1b_8OvE,7392
-firecrawl-4.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-firecrawl-4.4.0.dist-info/top_level.txt,sha256=8T3jOaSN5mtLghO-R3MQ8KO290gIX8hmfxQmglBPdLE,16
-firecrawl-4.4.0.dist-info/RECORD,,
+firecrawl-4.5.0.dist-info/METADATA,sha256=2VyFb6xIR5LW8RItrgSwkVofbg5f4fH68qE9PRfnxc4,7392
+firecrawl-4.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+firecrawl-4.5.0.dist-info/top_level.txt,sha256=8T3jOaSN5mtLghO-R3MQ8KO290gIX8hmfxQmglBPdLE,16
+firecrawl-4.5.0.dist-info/RECORD,,

tests/test_api_key_handling.py

@@ -0,0 +1,44 @@
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from firecrawl.v2.client import FirecrawlClient
+from firecrawl.v2.client_async import AsyncFirecrawlClient
+
+
+@pytest.fixture(autouse=True)
+def clear_firecrawl_api_key_env(monkeypatch):
+    monkeypatch.delenv("FIRECRAWL_API_KEY", raising=False)
+    yield
+
+
+def test_cloud_requires_api_key():
+    with pytest.raises(ValueError):
+        FirecrawlClient(api_url="https://api.firecrawl.dev")
+
+
+def test_self_host_allows_missing_api_key():
+    client = FirecrawlClient(api_url="http://localhost:3000")
+    assert client.http_client.api_key is None
+
+
+def test_async_cloud_requires_api_key():
+    with pytest.raises(ValueError):
+        AsyncFirecrawlClient(api_url="https://api.firecrawl.dev")
+
+
+@pytest.mark.asyncio
+async def test_async_self_host_allows_missing_api_key():
+    client = AsyncFirecrawlClient(api_url="http://localhost:3000")
+    try:
+        assert client.http_client.api_key is None
+        await client.async_http_client.close()
+    finally:
+        # Ensure the underlying HTTPX client is closed even if assertions fail
+        if not client.async_http_client._client.is_closed:
+            await client.async_http_client.close()