firecrawl-py 2.16.3__py3-none-any.whl → 3.0.2__py3-none-any.whl

firecrawl/{firecrawl.py → v1/client.py}

@@ -1,13 +1,15 @@
 """
-FirecrawlApp Module
+Firecrawl v1 API Client - Legacy Implementation
 
-This module provides a class `FirecrawlApp` for interacting with the Firecrawl API.
-It includes methods to scrape URLs, perform searches, initiate and monitor crawl jobs,
-and check the status of these jobs. The module uses requests for HTTP communication
-and handles retries for certain HTTP status codes.
+This module provides the legacy v1 implementation of the Firecrawl SDK.
+It contains the complete `V1FirecrawlApp` class with all v1 API methods and types
+for backward compatibility. This is used by the unified client to provide
+version-specific access patterns like app.v1.scrape_url().
 
 Classes:
-    - FirecrawlApp: Main class for interacting with the Firecrawl API.
+    - V1FirecrawlApp: Legacy v1 client for interacting with the Firecrawl API.
+    - AsyncV1FirecrawlApp: Async version of the v1 client.
+    - CrawlWatcher: WebSocket-based crawl monitoring for v1.
 """
 import logging
 import os
@@ -16,20 +18,13 @@ from typing import Any, Dict, Optional, List, Union, Callable, Literal, TypeVar,
 import json
 from datetime import datetime
 import re
-import warnings
 import requests
 import pydantic
 import websockets
 import aiohttp
 import asyncio
-from pydantic import Field
 
-# Suppress Pydantic warnings about attribute shadowing
-warnings.filterwarnings("ignore", message="Field name \"json\" in \"FirecrawlDocument\" shadows an attribute in parent \"BaseModel\"")
-warnings.filterwarnings("ignore", message="Field name \"json\" in \"ChangeTrackingData\" shadows an attribute in parent \"BaseModel\"")
-warnings.filterwarnings("ignore", message="Field name \"schema\" in \"JsonConfig\" shadows an attribute in parent \"BaseModel\"")
-warnings.filterwarnings("ignore", message="Field name \"schema\" in \"ExtractParams\" shadows an attribute in parent \"BaseModel\"")
-warnings.filterwarnings("ignore", message="Field name \"schema\" in \"ChangeTrackingOptions\" shadows an attribute in parent \"BaseModel\"")
+logger : logging.Logger = logging.getLogger("firecrawl")
 
 def get_version():
   try:
@@ -45,11 +40,9 @@ def get_version():
 
 version = get_version()
 
-logger : logging.Logger = logging.getLogger("firecrawl")
-
 T = TypeVar('T')
 
-# class FirecrawlDocumentMetadata(pydantic.BaseModel):
+# class V1FirecrawlDocumentMetadata(pydantic.BaseModel):
 #     """Metadata for a Firecrawl document."""
 #     title: Optional[str] = None
 #     description: Optional[str] = None
@@ -84,21 +77,21 @@ T = TypeVar('T')
 #     statusCode: Optional[int] = None
 #     error: Optional[str] = None
 
-class AgentOptions(pydantic.BaseModel):
+class V1AgentOptions(pydantic.BaseModel):
     """Configuration for the agent."""
     model: Literal["FIRE-1"] = "FIRE-1"
     prompt: Optional[str] = None
 
-class AgentOptionsExtract(pydantic.BaseModel):
+class V1AgentOptionsExtract(pydantic.BaseModel):
     """Configuration for the agent in extract operations."""
     model: Literal["FIRE-1"] = "FIRE-1"
 
-class ActionsResult(pydantic.BaseModel):
+class V1ActionsResult(pydantic.BaseModel):
     """Result of actions performed during scraping."""
     screenshots: List[str]
     pdfs: List[str]
 
-class ChangeTrackingData(pydantic.BaseModel):
+class V1ChangeTrackingData(pydantic.BaseModel):
     """
     Data for the change tracking format.
     """
@@ -106,9 +99,9 @@ class ChangeTrackingData(pydantic.BaseModel):
     changeStatus: str  # "new" | "same" | "changed" | "removed"
     visibility: str  # "visible" | "hidden"
     diff: Optional[Dict[str, Any]] = None
-    json: Optional[Any] = None
+    json_field: Optional[Any] = pydantic.Field(None, alias='json')
 
-class FirecrawlDocument(pydantic.BaseModel, Generic[T]):
+class V1FirecrawlDocument(pydantic.BaseModel, Generic[T]):
     """Document retrieved or processed by Firecrawl."""
     url: Optional[str] = None
     markdown: Optional[str] = None
@@ -116,34 +109,34 @@ class FirecrawlDocument(pydantic.BaseModel, Generic[T]):
     rawHtml: Optional[str] = None
     links: Optional[List[str]] = None
     extract: Optional[T] = None
-    json: Optional[T] = None
+    json_field: Optional[T] = pydantic.Field(None, alias='json')
     screenshot: Optional[str] = None
     metadata: Optional[Any] = None
-    actions: Optional[ActionsResult] = None
+    actions: Optional[V1ActionsResult] = None
     title: Optional[str] = None  # v1 search only
     description: Optional[str] = None  # v1 search only
-    changeTracking: Optional[ChangeTrackingData] = None
+    changeTracking: Optional[V1ChangeTrackingData] = None
 
-class LocationConfig(pydantic.BaseModel):
+class V1LocationConfig(pydantic.BaseModel):
     """Location configuration for scraping."""
     country: Optional[str] = None
     languages: Optional[List[str]] = None
 
-class WebhookConfig(pydantic.BaseModel):
+class V1WebhookConfig(pydantic.BaseModel):
     """Configuration for webhooks."""
     url: str
     headers: Optional[Dict[str, str]] = None
     metadata: Optional[Dict[str, str]] = None
     events: Optional[List[Literal["completed", "failed", "page", "started"]]] = None
 
-class ChangeTrackingOptions(pydantic.BaseModel):
+class V1ChangeTrackingOptions(pydantic.BaseModel):
     """Configuration for change tracking."""
     modes: Optional[List[Literal["git-diff", "json"]]] = None
-    schema: Optional[Any] = None
+    schema_field: Optional[Any] = pydantic.Field(None, alias='schema')
     prompt: Optional[str] = None
     tag: Optional[str] = None
 
-class ScrapeOptions(pydantic.BaseModel):
+class V1ScrapeOptions(pydantic.BaseModel):
     """Parameters for scraping operations."""
     formats: Optional[List[Literal["markdown", "html", "rawHtml", "content", "links", "screenshot", "screenshot@fullPage", "extract", "json", "changeTracking"]]] = None
     headers: Optional[Dict[str, str]] = None
@@ -151,93 +144,93 @@ class ScrapeOptions(pydantic.BaseModel):
     excludeTags: Optional[List[str]] = None
     onlyMainContent: Optional[bool] = None
     waitFor: Optional[int] = None
-    timeout: Optional[int] = None
-    location: Optional[LocationConfig] = None
+    timeout: Optional[int] = 30000
+    location: Optional[V1LocationConfig] = None
     mobile: Optional[bool] = None
     skipTlsVerification: Optional[bool] = None
     removeBase64Images: Optional[bool] = None
     blockAds: Optional[bool] = None
     proxy: Optional[Literal["basic", "stealth", "auto"]] = None
-    changeTrackingOptions: Optional[ChangeTrackingOptions] = None
+    changeTrackingOptions: Optional[V1ChangeTrackingOptions] = None
     maxAge: Optional[int] = None
     storeInCache: Optional[bool] = None
     parsePDF: Optional[bool] = None
 
-class WaitAction(pydantic.BaseModel):
+class V1WaitAction(pydantic.BaseModel):
     """Wait action to perform during scraping."""
     type: Literal["wait"]
     milliseconds: Optional[int] = None
     selector: Optional[str] = None
 
-class ScreenshotAction(pydantic.BaseModel):
+class V1ScreenshotAction(pydantic.BaseModel):
     """Screenshot action to perform during scraping."""
     type: Literal["screenshot"]
     fullPage: Optional[bool] = None
     quality: Optional[int] = None
 
-class ClickAction(pydantic.BaseModel):
+class V1ClickAction(pydantic.BaseModel):
     """Click action to perform during scraping."""
     type: Literal["click"]
     selector: str
 
-class WriteAction(pydantic.BaseModel):
+class V1WriteAction(pydantic.BaseModel):
     """Write action to perform during scraping."""
     type: Literal["write"]
     text: str
 
-class PressAction(pydantic.BaseModel):
+class V1PressAction(pydantic.BaseModel):
     """Press action to perform during scraping."""
     type: Literal["press"]
     key: str
 
-class ScrollAction(pydantic.BaseModel):
+class V1ScrollAction(pydantic.BaseModel):
     """Scroll action to perform during scraping."""
     type: Literal["scroll"]
     direction: Literal["up", "down"]
     selector: Optional[str] = None
 
-class ScrapeAction(pydantic.BaseModel):
+class V1ScrapeAction(pydantic.BaseModel):
     """Scrape action to perform during scraping."""
     type: Literal["scrape"]
 
-class ExecuteJavascriptAction(pydantic.BaseModel):
+class V1ExecuteJavascriptAction(pydantic.BaseModel):
     """Execute javascript action to perform during scraping."""
     type: Literal["executeJavascript"]
     script: str
 
-class PDFAction(pydantic.BaseModel):
+class V1PDFAction(pydantic.BaseModel):
     """PDF action to perform during scraping."""
     type: Literal["pdf"]
     format: Optional[Literal["A0", "A1", "A2", "A3", "A4", "A5", "A6", "Letter", "Legal", "Tabloid", "Ledger"]] = None
     landscape: Optional[bool] = None
     scale: Optional[float] = None
 
-class ExtractAgent(pydantic.BaseModel):
+class V1ExtractAgent(pydantic.BaseModel):
     """Configuration for the agent in extract operations."""
     model: Literal["FIRE-1"] = "FIRE-1"
 
-class JsonConfig(pydantic.BaseModel):
+class V1JsonConfig(pydantic.BaseModel):
     """Configuration for extraction."""
     prompt: Optional[str] = None
-    schema: Optional[Any] = None
+    schema_field: Optional[Any] = pydantic.Field(None, alias='schema')
     systemPrompt: Optional[str] = None
-    agent: Optional[ExtractAgent] = None
+    agent: Optional[V1ExtractAgent] = None
 
-class ScrapeParams(ScrapeOptions):
+class V1ScrapeParams(V1ScrapeOptions):
     """Parameters for scraping operations."""
-    extract: Optional[JsonConfig] = None
-    jsonOptions: Optional[JsonConfig] = None
-    actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None
-    agent: Optional[AgentOptions] = None
-    webhook: Optional[WebhookConfig] = None
+    extract: Optional[V1JsonConfig] = None
+    jsonOptions: Optional[V1JsonConfig] = None
+    actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None
+    agent: Optional[V1AgentOptions] = None
+    webhook: Optional[V1WebhookConfig] = None
 
-class ScrapeResponse(FirecrawlDocument[T], Generic[T]):
+class V1ScrapeResponse(V1FirecrawlDocument[T], Generic[T]):
     """Response from scraping operations."""
     success: bool = True
     warning: Optional[str] = None
     error: Optional[str] = None
 
-class BatchScrapeResponse(pydantic.BaseModel):
+class V1BatchScrapeResponse(pydantic.BaseModel):
     """Response from batch scrape operations."""
     id: Optional[str] = None
     url: Optional[str] = None
@@ -245,7 +238,7 @@ class BatchScrapeResponse(pydantic.BaseModel):
     error: Optional[str] = None
     invalidURLs: Optional[List[str]] = None
 
-class BatchScrapeStatusResponse(pydantic.BaseModel):
+class V1BatchScrapeStatusResponse(pydantic.BaseModel):
     """Response from batch scrape status checks."""
     success: bool = True
     status: Literal["scraping", "completed", "failed", "cancelled"]
@@ -254,9 +247,9 @@ class BatchScrapeStatusResponse(pydantic.BaseModel):
     creditsUsed: int
     expiresAt: datetime
     next: Optional[str] = None
-    data: List[FirecrawlDocument]
+    data: List[V1FirecrawlDocument]
 
-class CrawlParams(pydantic.BaseModel):
+class V1CrawlParams(pydantic.BaseModel):
     """Parameters for crawling operations."""
     includePaths: Optional[List[str]] = None
     excludePaths: Optional[List[str]] = None
@@ -264,10 +257,11 @@ class CrawlParams(pydantic.BaseModel):
     maxDiscoveryDepth: Optional[int] = None
     limit: Optional[int] = None
     allowBackwardLinks: Optional[bool] = None
+    crawlEntireDomain: Optional[bool] = None
     allowExternalLinks: Optional[bool] = None
     ignoreSitemap: Optional[bool] = None
-    scrapeOptions: Optional[ScrapeOptions] = None
-    webhook: Optional[Union[str, WebhookConfig]] = None
+    scrapeOptions: Optional[V1ScrapeOptions] = None
+    webhook: Optional[Union[str, V1WebhookConfig]] = None
     deduplicateSimilarURLs: Optional[bool] = None
     ignoreQueryParameters: Optional[bool] = None
     regexOnFullURL: Optional[bool] = None
@@ -275,14 +269,14 @@ class CrawlParams(pydantic.BaseModel):
     maxConcurrency: Optional[int] = None
     allowSubdomains: Optional[bool] = None
 
-class CrawlResponse(pydantic.BaseModel):
+class V1CrawlResponse(pydantic.BaseModel):
     """Response from crawling operations."""
     id: Optional[str] = None
     url: Optional[str] = None
     success: bool = True
     error: Optional[str] = None
 
-class CrawlStatusResponse(pydantic.BaseModel):
+class V1CrawlStatusResponse(pydantic.BaseModel):
     """Response from crawl status checks."""
     success: bool = True
     status: Literal["scraping", "completed", "failed", "cancelled"]
@@ -291,42 +285,50 @@ class CrawlStatusResponse(pydantic.BaseModel):
     creditsUsed: int
     expiresAt: datetime
     next: Optional[str] = None
-    data: List[FirecrawlDocument]
+    data: List[V1FirecrawlDocument]
+
+class V1CrawlError(pydantic.BaseModel):
+    """A crawl error."""
+    id: str
+    timestamp: Optional[datetime] = None
+    url: str
+    code: Optional[str] = None
+    error: str
 
-class CrawlErrorsResponse(pydantic.BaseModel):
+class V1CrawlErrorsResponse(pydantic.BaseModel):
     """Response from crawl/batch scrape error monitoring."""
-    errors: List[Dict[str, str]]  # {id: str, timestamp: str, url: str, error: str}
+    errors: List[V1CrawlError]
     robotsBlocked: List[str]
 
-class MapParams(pydantic.BaseModel):
+class V1MapParams(pydantic.BaseModel):
     """Parameters for mapping operations."""
     search: Optional[str] = None
     ignoreSitemap: Optional[bool] = None
     includeSubdomains: Optional[bool] = None
     sitemapOnly: Optional[bool] = None
     limit: Optional[int] = None
-    timeout: Optional[int] = None
+    timeout: Optional[int] = 30000
     useIndex: Optional[bool] = None
 
-class MapResponse(pydantic.BaseModel):
+class V1MapResponse(pydantic.BaseModel):
     """Response from mapping operations."""
     success: bool = True
     links: Optional[List[str]] = None
     error: Optional[str] = None
 
-class ExtractParams(pydantic.BaseModel):
+class V1ExtractParams(pydantic.BaseModel):
     """Parameters for extracting information from URLs."""
     prompt: Optional[str] = None
-    schema: Optional[Any] = None
+    schema_field: Optional[Any] = pydantic.Field(None, alias='schema')
     systemPrompt: Optional[str] = None
     allowExternalLinks: Optional[bool] = None
     enableWebSearch: Optional[bool] = None
     includeSubdomains: Optional[bool] = None
     origin: Optional[str] = None
     showSources: Optional[bool] = None
-    scrapeOptions: Optional[ScrapeOptions] = None
+    scrapeOptions: Optional[V1ScrapeOptions] = None
 
-class ExtractResponse(pydantic.BaseModel, Generic[T]):
+class V1ExtractResponse(pydantic.BaseModel, Generic[T]):
     """Response from extract operations."""
     id: Optional[str] = None
     status: Optional[Literal["processing", "completed", "failed"]] = None
@@ -337,7 +339,7 @@ class ExtractResponse(pydantic.BaseModel, Generic[T]):
     warning: Optional[str] = None
     sources: Optional[Dict[Any, Any]] = None
 
-class SearchParams(pydantic.BaseModel):
+class V1SearchParams(pydantic.BaseModel):
     query: str
     limit: Optional[int] = 5
     tbs: Optional[str] = None
@@ -347,16 +349,16 @@ class SearchParams(pydantic.BaseModel):
     location: Optional[str] = None
     origin: Optional[str] = "api"
     timeout: Optional[int] = 60000
-    scrapeOptions: Optional[ScrapeOptions] = None
+    scrapeOptions: Optional[V1ScrapeOptions] = None
 
-class SearchResponse(pydantic.BaseModel):
+class V1SearchResponse(pydantic.BaseModel):
     """Response from search operations."""
     success: bool = True
-    data: List[FirecrawlDocument]
+    data: List[V1FirecrawlDocument]
     warning: Optional[str] = None
     error: Optional[str] = None
 
-class GenerateLLMsTextParams(pydantic.BaseModel):
+class V1GenerateLLMsTextParams(pydantic.BaseModel):
     """
     Parameters for the LLMs.txt generation operation.
     """
@@ -365,7 +367,7 @@ class GenerateLLMsTextParams(pydantic.BaseModel):
     cache: Optional[bool] = True
     __experimental_stream: Optional[bool] = None
 
-class DeepResearchParams(pydantic.BaseModel):
+class V1DeepResearchParams(pydantic.BaseModel):
     """
     Parameters for the deep research operation.
     """
@@ -376,7 +378,7 @@ class DeepResearchParams(pydantic.BaseModel):
     systemPrompt: Optional[str] = None
     __experimental_streamSteps: Optional[bool] = None
 
-class DeepResearchResponse(pydantic.BaseModel):
+class V1DeepResearchResponse(pydantic.BaseModel):
     """
     Response from the deep research operation.
     """
@@ -384,7 +386,7 @@ class DeepResearchResponse(pydantic.BaseModel):
     id: str
     error: Optional[str] = None
 
-class DeepResearchStatusResponse(pydantic.BaseModel):
+class V1DeepResearchStatusResponse(pydantic.BaseModel):
     """
     Status response from the deep research operation.
     """
@@ -399,25 +401,25 @@ class DeepResearchStatusResponse(pydantic.BaseModel):
     sources: List[Dict[str, Any]]
     summaries: List[str]
 
-class GenerateLLMsTextResponse(pydantic.BaseModel):
+class V1GenerateLLMsTextResponse(pydantic.BaseModel):
     """Response from LLMs.txt generation operations."""
     success: bool = True
     id: str
     error: Optional[str] = None
 
-class GenerateLLMsTextStatusResponseData(pydantic.BaseModel):
+class V1GenerateLLMsTextStatusResponseData(pydantic.BaseModel):
     llmstxt: str
     llmsfulltxt: Optional[str] = None
 
-class GenerateLLMsTextStatusResponse(pydantic.BaseModel):
+class V1GenerateLLMsTextStatusResponse(pydantic.BaseModel):
     """Status response from LLMs.txt generation operations."""
     success: bool = True
-    data: Optional[GenerateLLMsTextStatusResponseData] = None
+    data: Optional[V1GenerateLLMsTextStatusResponseData] = None
     status: Literal["processing", "completed", "failed"]
     error: Optional[str] = None
     expiresAt: str
     
-class SearchResponse(pydantic.BaseModel):
+class V1SearchResponse(pydantic.BaseModel):
     """
     Response from the search operation.
     """
@@ -426,12 +428,12 @@ class SearchResponse(pydantic.BaseModel):
     warning: Optional[str] = None
     error: Optional[str] = None
 
-class ExtractParams(pydantic.BaseModel):
+class V1ExtractParams(pydantic.BaseModel):
     """
     Parameters for the extract operation.
     """
     prompt: Optional[str] = None
-    schema: Optional[Any] = pydantic.Field(None, alias='schema')
+    schema_field: Optional[Any] = pydantic.Field(None, alias='schema')
     system_prompt: Optional[str] = None
     allow_external_links: Optional[bool] = False
     enable_web_search: Optional[bool] = False
@@ -440,10 +442,25 @@ class ExtractParams(pydantic.BaseModel):
     show_sources: Optional[bool] = False
     agent: Optional[Dict[str, Any]] = None
 
-class FirecrawlApp:
+class V1FirecrawlApp:
+    """
+    Legacy v1 Firecrawl client for backward compatibility.
+    
+    This class provides the complete v1 API implementation including:
+    - URL scraping with various formats and options
+    - Website crawling with monitoring capabilities
+    - Batch scraping operations
+    - Search functionality
+    - Data extraction with LLM integration
+    - Deep research capabilities
+    - LLMs.txt generation
+    
+    This is used by the unified client to provide version-specific access
+    through app.v1.method_name() patterns.
+    """
     def __init__(self, api_key: Optional[str] = None, api_url: Optional[str] = None) -> None:
         """
-        Initialize the FirecrawlApp instance with API key, API URL.
+        Initialize the V1FirecrawlApp instance with API key, API URL.
 
         Args:
             api_key (Optional[str]): API key for authenticating with the Firecrawl API.
@@ -457,7 +474,7 @@ class FirecrawlApp:
             logger.warning("No API key provided for cloud service")
             raise ValueError('No API key provided')
             
-        logger.debug(f"Initialized FirecrawlApp with API URL: {self.api_url}")
+        logger.debug(f"Initialized V1FirecrawlApp with API URL: {self.api_url}")
 
     def scrape_url(
             self,
@@ -469,22 +486,22 @@ class FirecrawlApp:
             exclude_tags: Optional[List[str]] = None,
             only_main_content: Optional[bool] = None,
             wait_for: Optional[int] = None,
-            timeout: Optional[int] = None,
-            location: Optional[LocationConfig] = None,
+            timeout: Optional[int] = 30000,
+            location: Optional[V1LocationConfig] = None,
             mobile: Optional[bool] = None,
             skip_tls_verification: Optional[bool] = None,
             remove_base64_images: Optional[bool] = None,
             block_ads: Optional[bool] = None,
             proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
             parse_pdf: Optional[bool] = None,
-            extract: Optional[JsonConfig] = None,
-            json_options: Optional[JsonConfig] = None,
-            actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-            change_tracking_options: Optional[ChangeTrackingOptions] = None,
+            extract: Optional[V1JsonConfig] = None,
+            json_options: Optional[V1JsonConfig] = None,
+            actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+            change_tracking_options: Optional[V1ChangeTrackingOptions] = None,
             max_age: Optional[int] = None,
             store_in_cache: Optional[bool] = None,
             zero_data_retention: Optional[bool] = None,
-            **kwargs) -> ScrapeResponse[Any]:
+            **kwargs) -> V1ScrapeResponse[Any]:
         """
         Scrape and extract content from a URL.
 
@@ -547,7 +564,7 @@ class FirecrawlApp:
         if timeout:
             scrape_params['timeout'] = timeout
         if location:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -564,16 +581,16 @@ class FirecrawlApp:
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
         if actions:
-            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(exclude_none=True) for action in actions]
+            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(by_alias=True, exclude_none=True) for action in actions]
         if change_tracking_options:
-            scrape_params['changeTrackingOptions'] = change_tracking_options if isinstance(change_tracking_options, dict) else change_tracking_options.dict(exclude_none=True)
+            scrape_params['changeTrackingOptions'] = change_tracking_options if isinstance(change_tracking_options, dict) else change_tracking_options.dict(by_alias=True, exclude_none=True)
         if max_age is not None:
             scrape_params['maxAge'] = max_age
         if store_in_cache is not None:
@@ -593,14 +610,14 @@ class FirecrawlApp:
             f'{self.api_url}/v1/scrape',
             headers=_headers,
             json=scrape_params,
-            timeout=(timeout + 5000 if timeout else None)
+            timeout=(timeout / 1000.0 + 5 if timeout is not None else None)
         )
 
         if response.status_code == 200:
             try:
                 response_json = response.json()
                 if response_json.get('success') and 'data' in response_json:
-                    return ScrapeResponse(**response_json['data'])
+                    return V1ScrapeResponse(**response_json['data'])
                 elif "error" in response_json:
                     raise Exception(f'Failed to scrape URL. Error: {response_json["error"]}')
                 else:
@@ -620,9 +637,9 @@ class FirecrawlApp:
             lang: Optional[str] = None,
             country: Optional[str] = None,
             location: Optional[str] = None,
-            timeout: Optional[int] = None,
-            scrape_options: Optional[ScrapeOptions] = None,
-            **kwargs) -> SearchResponse:
+            timeout: Optional[int] = 30000,
+            scrape_options: Optional[V1ScrapeOptions] = None,
+            **kwargs) -> V1SearchResponse:
         """
         Search for content using Firecrawl.
 
@@ -670,15 +687,15 @@ class FirecrawlApp:
         if timeout is not None:
             search_params['timeout'] = timeout
         if scrape_options is not None:
-            search_params['scrapeOptions'] = scrape_options.dict(exclude_none=True)
+            search_params['scrapeOptions'] = scrape_options.dict(by_alias=True, exclude_none=True)
         
         # Add any additional kwargs
         search_params.update(kwargs)
         _integration = search_params.get('integration')
 
         # Create final params object
-        final_params = SearchParams(query=query, **search_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1SearchParams(query=query, **search_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['origin'] = f"python-sdk@{version}"
 
         if _integration:
@@ -695,7 +712,7 @@ class FirecrawlApp:
             try:
                 response_json = response.json()
                 if response_json.get('success') and 'data' in response_json:
-                    return SearchResponse(**response_json)
+                    return V1SearchResponse(**response_json)
                 elif "error" in response_json:
                     raise Exception(f'Search failed. Error: {response_json["error"]}')
                 else:
@@ -718,8 +735,8 @@ class FirecrawlApp:
         crawl_entire_domain: Optional[bool] = None,
         allow_external_links: Optional[bool] = None,
         ignore_sitemap: Optional[bool] = None,
-        scrape_options: Optional[ScrapeOptions] = None,
-        webhook: Optional[Union[str, WebhookConfig]] = None,
+        scrape_options: Optional[V1ScrapeOptions] = None,
+        webhook: Optional[Union[str, V1WebhookConfig]] = None,
         deduplicate_similar_urls: Optional[bool] = None,
         ignore_query_parameters: Optional[bool] = None,
         regex_on_full_url: Optional[bool] = None,
@@ -730,7 +747,7 @@ class FirecrawlApp:
         poll_interval: Optional[int] = 2,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> CrawlStatusResponse:
+    ) -> V1CrawlStatusResponse:
         """
         Crawl a website starting from a URL.
 
@@ -792,7 +809,7 @@ class FirecrawlApp:
         if ignore_sitemap is not None:
             crawl_params['ignoreSitemap'] = ignore_sitemap
         if scrape_options is not None:
-            crawl_params['scrapeOptions'] = scrape_options.dict(exclude_none=True)
+            crawl_params['scrapeOptions'] = scrape_options.dict(by_alias=True, exclude_none=True)
         if webhook is not None:
             crawl_params['webhook'] = webhook
         if deduplicate_similar_urls is not None:
@@ -814,8 +831,8 @@ class FirecrawlApp:
         _integration = crawl_params.get('integration')
 
         # Create final params object
-        final_params = CrawlParams(**crawl_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1CrawlParams(**crawl_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['url'] = url
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -848,8 +865,8 @@ class FirecrawlApp:
         crawl_entire_domain: Optional[bool] = None,
         allow_external_links: Optional[bool] = None,
         ignore_sitemap: Optional[bool] = None,
-        scrape_options: Optional[ScrapeOptions] = None,
-        webhook: Optional[Union[str, WebhookConfig]] = None,
+        scrape_options: Optional[V1ScrapeOptions] = None,
+        webhook: Optional[Union[str, V1WebhookConfig]] = None,
         deduplicate_similar_urls: Optional[bool] = None,
         ignore_query_parameters: Optional[bool] = None,
         regex_on_full_url: Optional[bool] = None,
@@ -859,7 +876,7 @@ class FirecrawlApp:
         zero_data_retention: Optional[bool] = None,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> CrawlResponse:
+    ) -> V1CrawlResponse:
         """
         Start an asynchronous crawl job.
 
@@ -874,8 +891,8 @@ class FirecrawlApp:
             crawl_entire_domain (Optional[bool]): Follow parent directory links
             allow_external_links (Optional[bool]): Follow external domain links
             ignore_sitemap (Optional[bool]): Skip sitemap.xml processing
-            scrape_options (Optional[ScrapeOptions]): Page scraping configuration
-            webhook (Optional[Union[str, WebhookConfig]]): Notification webhook settings
+            scrape_options (Optional[V1ScrapeOptions]): Page scraping configuration
+            webhook (Optional[Union[str, V1WebhookConfig]]): Notification webhook settings
             deduplicate_similar_urls (Optional[bool]): Remove similar URLs
             ignore_query_parameters (Optional[bool]): Ignore URL parameters
             regex_on_full_url (Optional[bool]): Apply regex to full URLs
@@ -887,7 +904,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            CrawlResponse with:
+            V1CrawlResponse with:
             * success - Whether crawl started successfully
             * id - Unique identifier for the crawl job
             * url - Status check URL for the crawl
@@ -921,7 +938,7 @@ class FirecrawlApp:
         if ignore_sitemap is not None:
             crawl_params['ignoreSitemap'] = ignore_sitemap
         if scrape_options is not None:
-            crawl_params['scrapeOptions'] = scrape_options.dict(exclude_none=True)
+            crawl_params['scrapeOptions'] = scrape_options.dict(by_alias=True, exclude_none=True)
         if webhook is not None:
             crawl_params['webhook'] = webhook
         if deduplicate_similar_urls is not None:
@@ -942,8 +959,8 @@ class FirecrawlApp:
         crawl_params.update(kwargs)
 
         # Create final params object
-        final_params = CrawlParams(**crawl_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1CrawlParams(**crawl_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['url'] = url
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -953,13 +970,13 @@ class FirecrawlApp:
 
         if response.status_code == 200:
             try:
-                return CrawlResponse(**response.json())
+                return V1CrawlResponse(**response.json())
             except:
                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
         else:
             self._handle_error(response, 'start crawl job')
 
-    def check_crawl_status(self, id: str) -> CrawlStatusResponse:
+    def check_crawl_status(self, id: str) -> V1CrawlStatusResponse:
         """
         Check the status and results of a crawl job.
 
@@ -967,7 +984,7 @@ class FirecrawlApp:
             id: Unique identifier for the crawl job
 
         Returns:
-            CrawlStatusResponse containing:
+            V1CrawlStatusResponse containing:
 
             Status Information:
             * status - Current state (scraping/completed/failed/cancelled)
@@ -1035,14 +1052,14 @@ class FirecrawlApp:
             if 'next' in status_data:
                 response['next'] = status_data['next']
 
-            return CrawlStatusResponse(
+            return V1CrawlStatusResponse(
                 success=False if 'error' in status_data else True,
                 **response
             )
         else:
             self._handle_error(response, 'check crawl status')
     
-    def check_crawl_errors(self, id: str) -> CrawlErrorsResponse:
+    def check_crawl_errors(self, id: str) -> V1CrawlErrorsResponse:
         """
         Returns information about crawl errors.
 
@@ -1050,7 +1067,7 @@ class FirecrawlApp:
             id (str): The ID of the crawl job
 
         Returns:
-            CrawlErrorsResponse containing:
+            V1CrawlErrorsResponse containing:
             * errors (List[Dict[str, str]]): List of errors with fields:
                 - id (str): Error ID
                 - timestamp (str): When the error occurred
@@ -1065,7 +1082,7 @@ class FirecrawlApp:
         response = self._get_request(f'{self.api_url}/v1/crawl/{id}/errors', headers)
         if response.status_code == 200:
             try:
-                return CrawlErrorsResponse(**response.json())
+                return V1CrawlErrorsResponse(**response.json())
             except:
                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
         else:
@@ -1109,8 +1126,8 @@ class FirecrawlApp:
             crawl_entire_domain: Optional[bool] = None,
             allow_external_links: Optional[bool] = None,
             ignore_sitemap: Optional[bool] = None,
-            scrape_options: Optional[ScrapeOptions] = None,
-            webhook: Optional[Union[str, WebhookConfig]] = None,
+            scrape_options: Optional[V1ScrapeOptions] = None,
+            webhook: Optional[Union[str, V1WebhookConfig]] = None,
             deduplicate_similar_urls: Optional[bool] = None,
             ignore_query_parameters: Optional[bool] = None,
             regex_on_full_url: Optional[bool] = None,
@@ -1120,7 +1137,7 @@ class FirecrawlApp:
             zero_data_retention: Optional[bool] = None,
             idempotency_key: Optional[str] = None,
             **kwargs
-    ) -> 'CrawlWatcher':
+    ) -> 'V1CrawlWatcher':
         """
         Initiate a crawl job and return a CrawlWatcher to monitor the job via WebSocket.
 
@@ -1135,8 +1152,8 @@ class FirecrawlApp:
             crawl_entire_domain (Optional[bool]): Follow parent directory links
             allow_external_links (Optional[bool]): Follow external domain links
             ignore_sitemap (Optional[bool]): Skip sitemap.xml processing
-            scrape_options (Optional[ScrapeOptions]): Page scraping configuration
-            webhook (Optional[Union[str, WebhookConfig]]): Notification webhook settings
+            scrape_options (Optional[V1ScrapeOptions]): Page scraping configuration
+            webhook (Optional[Union[str, V1WebhookConfig]]): Notification webhook settings
             deduplicate_similar_urls (Optional[bool]): Remove similar URLs
             ignore_query_parameters (Optional[bool]): Ignore URL parameters
             regex_on_full_url (Optional[bool]): Apply regex to full URLs
@@ -1148,7 +1165,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            CrawlWatcher: An instance to monitor the crawl job via WebSocket
+            V1CrawlWatcher: An instance to monitor the crawl job via WebSocket
 
         Raises:
             Exception: If crawl job fails to start
@@ -1161,6 +1178,7 @@ class FirecrawlApp:
             max_discovery_depth=max_discovery_depth,
             limit=limit,
             allow_backward_links=allow_backward_links,
+            crawl_entire_domain=crawl_entire_domain,
             allow_external_links=allow_external_links,
             ignore_sitemap=ignore_sitemap,
             scrape_options=scrape_options,
@@ -1176,7 +1194,7 @@ class FirecrawlApp:
             **kwargs
         )
         if crawl_response.success and crawl_response.id:
-            return CrawlWatcher(crawl_response.id, self)
+            return V1CrawlWatcher(crawl_response.id, self)
         else:
             raise Exception("Crawl job failed to start")
 
@@ -1189,9 +1207,9 @@ class FirecrawlApp:
             include_subdomains: Optional[bool] = None,
             sitemap_only: Optional[bool] = None,
             limit: Optional[int] = None,
-            timeout: Optional[int] = None,
+            timeout: Optional[int] = 30000,
             use_index: Optional[bool] = None,
-            **kwargs) -> MapResponse:
+            **kwargs) -> V1MapResponse:
         """
         Map and discover links from a URL.
 
@@ -1206,7 +1224,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            MapResponse: Response containing:
+            V1MapResponse: Response containing:
                 * success (bool): Whether request succeeded
                 * links (List[str]): Discovered URLs
                 * error (Optional[str]): Error message if any
@@ -1241,8 +1259,8 @@ class FirecrawlApp:
         _integration = map_params.get('integration')
 
         # Create final params object
-        final_params = MapParams(**map_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1MapParams(**map_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['url'] = url
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -1260,7 +1278,7 @@ class FirecrawlApp:
             try:
                 response_json = response.json()
                 if response_json.get('success') and 'links' in response_json:
-                    return MapResponse(**response_json)
+                    return V1MapResponse(**response_json)
                 elif "error" in response_json:
                     raise Exception(f'Map failed. Error: {response_json["error"]}')
                 else:
@@ -1280,23 +1298,23 @@ class FirecrawlApp:
         exclude_tags: Optional[List[str]] = None,
         only_main_content: Optional[bool] = None,
         wait_for: Optional[int] = None,
-        timeout: Optional[int] = None,
-        location: Optional[LocationConfig] = None,
+        timeout: Optional[int] = 30000,
+        location: Optional[V1LocationConfig] = None,
         mobile: Optional[bool] = None,
         skip_tls_verification: Optional[bool] = None,
         remove_base64_images: Optional[bool] = None,
         block_ads: Optional[bool] = None,
         proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
-        extract: Optional[JsonConfig] = None,
-        json_options: Optional[JsonConfig] = None,
-        actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-        agent: Optional[AgentOptions] = None,
+        extract: Optional[V1JsonConfig] = None,
+        json_options: Optional[V1JsonConfig] = None,
+        actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+        agent: Optional[V1AgentOptions] = None,
         poll_interval: Optional[int] = 2,
         max_concurrency: Optional[int] = None,
         zero_data_retention: Optional[bool] = None,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> BatchScrapeStatusResponse:
+    ) -> V1BatchScrapeStatusResponse:
         """
         Batch scrape multiple URLs and monitor until completion.
 
@@ -1325,7 +1343,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            BatchScrapeStatusResponse with:
+            V1BatchScrapeStatusResponse with:
             * Scraping status and progress
             * Scraped content for each URL
             * Success/error information
@@ -1354,7 +1372,7 @@ class FirecrawlApp:
         if timeout is not None:
             scrape_params['timeout'] = timeout
         if location is not None:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -1369,16 +1387,16 @@ class FirecrawlApp:
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
         if actions:
-            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(exclude_none=True) for action in actions]
+            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(by_alias=True, exclude_none=True) for action in actions]
         if agent is not None:
-            scrape_params['agent'] = agent.dict(exclude_none=True)
+            scrape_params['agent'] = agent.dict(by_alias=True, exclude_none=True)
         if max_concurrency is not None:
             scrape_params['maxConcurrency'] = max_concurrency
         if zero_data_retention is not None:
@@ -1388,8 +1406,8 @@ class FirecrawlApp:
         scrape_params.update(kwargs)
 
         # Create final params object
-        final_params = ScrapeParams(**scrape_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1ScrapeParams(**scrape_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -1421,22 +1439,22 @@ class FirecrawlApp:
         exclude_tags: Optional[List[str]] = None,
         only_main_content: Optional[bool] = None,
         wait_for: Optional[int] = None,
-        timeout: Optional[int] = None,
-        location: Optional[LocationConfig] = None,
+        timeout: Optional[int] = 30000,
+        location: Optional[V1LocationConfig] = None,
         mobile: Optional[bool] = None,
         skip_tls_verification: Optional[bool] = None,
         remove_base64_images: Optional[bool] = None,
         block_ads: Optional[bool] = None,
         proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
-        extract: Optional[JsonConfig] = None,
-        json_options: Optional[JsonConfig] = None,
-        actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-        agent: Optional[AgentOptions] = None,
+        extract: Optional[V1JsonConfig] = None,
+        json_options: Optional[V1JsonConfig] = None,
+        actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+        agent: Optional[V1AgentOptions] = None,
         max_concurrency: Optional[int] = None,
         idempotency_key: Optional[str] = None,
         zero_data_retention: Optional[bool] = None,
         **kwargs
-    ) -> BatchScrapeResponse:
+    ) -> V1BatchScrapeResponse:
         """
         Initiate a batch scrape job asynchronously.
 
@@ -1465,7 +1483,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            BatchScrapeResponse with:
+            V1BatchScrapeResponse with:
             * success - Whether job started successfully
             * id - Unique identifier for the job
             * url - Status check URL
@@ -1495,7 +1513,7 @@ class FirecrawlApp:
         if timeout is not None:
             scrape_params['timeout'] = timeout
         if location is not None:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -1510,16 +1528,16 @@ class FirecrawlApp:
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
         if actions:
-            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(exclude_none=True) for action in actions]
+            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(by_alias=True, exclude_none=True) for action in actions]
         if agent is not None:
-            scrape_params['agent'] = agent.dict(exclude_none=True)
+            scrape_params['agent'] = agent.dict(by_alias=True, exclude_none=True)
         if max_concurrency is not None:
             scrape_params['maxConcurrency'] = max_concurrency
         if zero_data_retention is not None:
@@ -1529,8 +1547,8 @@ class FirecrawlApp:
         scrape_params.update(kwargs)
 
         # Create final params object
-        final_params = ScrapeParams(**scrape_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1ScrapeParams(**scrape_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -1545,7 +1563,7 @@ class FirecrawlApp:
 
         if response.status_code == 200:
             try:
-                return BatchScrapeResponse(**response.json())
+                return V1BatchScrapeResponse(**response.json())
             except:
                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
         else:
@@ -1561,22 +1579,22 @@ class FirecrawlApp:
         exclude_tags: Optional[List[str]] = None,
         only_main_content: Optional[bool] = None,
         wait_for: Optional[int] = None,
-        timeout: Optional[int] = None,
-        location: Optional[LocationConfig] = None,
+        timeout: Optional[int] = 30000,
+        location: Optional[V1LocationConfig] = None,
         mobile: Optional[bool] = None,
         skip_tls_verification: Optional[bool] = None,
         remove_base64_images: Optional[bool] = None,
         block_ads: Optional[bool] = None,
         proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
-        extract: Optional[JsonConfig] = None,
-        json_options: Optional[JsonConfig] = None,
-        actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-        agent: Optional[AgentOptions] = None,
+        extract: Optional[V1JsonConfig] = None,
+        json_options: Optional[V1JsonConfig] = None,
+        actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+        agent: Optional[V1AgentOptions] = None,
         max_concurrency: Optional[int] = None,
         zero_data_retention: Optional[bool] = None,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> 'CrawlWatcher':
+    ) -> 'V1CrawlWatcher':
         """
         Initiate a batch scrape job and return a CrawlWatcher to monitor the job via WebSocket.
 
@@ -1605,7 +1623,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            CrawlWatcher: An instance to monitor the batch scrape job via WebSocket
+            V1CrawlWatcher: An instance to monitor the batch scrape job via WebSocket
 
         Raises:
             Exception: If batch scrape job fails to start
@@ -1631,7 +1649,7 @@ class FirecrawlApp:
         if timeout is not None:
             scrape_params['timeout'] = timeout
         if location is not None:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -1646,16 +1664,16 @@ class FirecrawlApp:
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
         if actions:
-            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(exclude_none=True) for action in actions]
+            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(by_alias=True, exclude_none=True) for action in actions]
         if agent is not None:
-            scrape_params['agent'] = agent.dict(exclude_none=True)
+            scrape_params['agent'] = agent.dict(by_alias=True, exclude_none=True)
         if max_concurrency is not None:
             scrape_params['maxConcurrency'] = max_concurrency
         if zero_data_retention is not None:
@@ -1665,8 +1683,8 @@ class FirecrawlApp:
         scrape_params.update(kwargs)
 
         # Create final params object
-        final_params = ScrapeParams(**scrape_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1ScrapeParams(**scrape_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -1681,9 +1699,9 @@ class FirecrawlApp:
 
         if response.status_code == 200:
             try:
-                crawl_response = BatchScrapeResponse(**response.json())
+                crawl_response = V1BatchScrapeResponse(**response.json())
                 if crawl_response.success and crawl_response.id:
-                    return CrawlWatcher(crawl_response.id, self)
+                    return V1CrawlWatcher(crawl_response.id, self)
                 else:
                     raise Exception("Batch scrape job failed to start")
             except:
@@ -1691,7 +1709,7 @@ class FirecrawlApp:
         else:
             self._handle_error(response, 'start batch scrape job')
     
-    def check_batch_scrape_status(self, id: str) -> BatchScrapeStatusResponse:
+    def check_batch_scrape_status(self, id: str) -> V1BatchScrapeStatusResponse:
         """
         Check the status of a batch scrape job using the Firecrawl API.
 
@@ -1699,7 +1717,7 @@ class FirecrawlApp:
             id (str): The ID of the batch scrape job.
 
         Returns:
-            BatchScrapeStatusResponse: The status of the batch scrape job.
+            V1BatchScrapeStatusResponse: The status of the batch scrape job.
 
         Raises:
             Exception: If the status check request fails.
@@ -1739,7 +1757,7 @@ class FirecrawlApp:
                             break
                     status_data['data'] = data
 
-            return BatchScrapeStatusResponse(**{
+            return V1BatchScrapeStatusResponse(**{
                 'success': False if 'error' in status_data else True,
                 'status': status_data.get('status'),
                 'total': status_data.get('total'),
@@ -1753,7 +1771,7 @@ class FirecrawlApp:
         else:
             self._handle_error(response, 'check batch scrape status')
 
-    def check_batch_scrape_errors(self, id: str) -> CrawlErrorsResponse:
+    def check_batch_scrape_errors(self, id: str) -> V1CrawlErrorsResponse:
         """
         Returns information about batch scrape errors.
 
@@ -1761,7 +1779,7 @@ class FirecrawlApp:
             id (str): The ID of the crawl job.
 
         Returns:
-            CrawlErrorsResponse containing:
+            V1CrawlErrorsResponse containing:
             * errors (List[Dict[str, str]]): List of errors with fields:
               * id (str): Error ID
               * timestamp (str): When the error occurred
@@ -1776,7 +1794,7 @@ class FirecrawlApp:
         response = self._get_request(f'{self.api_url}/v1/batch/scrape/{id}/errors', headers)
         if response.status_code == 200:
             try:
-                return CrawlErrorsResponse(**response.json())
+                return V1CrawlErrorsResponse(**response.json())
             except:
                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
         else:
@@ -1793,7 +1811,7 @@ class FirecrawlApp:
             enable_web_search: Optional[bool] = False,
             show_sources: Optional[bool] = False,
             agent: Optional[Dict[str, Any]] = None,
-            **kwargs) -> ExtractResponse[Any]:
+            **kwargs) -> V1ExtractResponse[Any]:
         """
         Extract structured information from URLs.
 
@@ -1809,7 +1827,7 @@ class FirecrawlApp:
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            ExtractResponse[Any] with:
+            V1ExtractResponse[Any] with:
             * success (bool): Whether request succeeded
             * data (Optional[Any]): Extracted data matching schema
             * error (Optional[str]): Error message if any
@@ -1881,7 +1899,7 @@ class FirecrawlApp:
                             except:
                                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
                             if status_data['status'] == 'completed':
-                                return ExtractResponse(**status_data)
+                                return V1ExtractResponse(**status_data)
                             elif status_data['status'] in ['failed', 'cancelled']:
                                 raise Exception(f'Extract job {status_data["status"]}. Error: {status_data["error"]}')
                         else:
@@ -1895,9 +1913,9 @@ class FirecrawlApp:
         except Exception as e:
             raise ValueError(str(e), 500)
 
-        return ExtractResponse(success=False, error="Internal server error.")
+        return V1ExtractResponse(success=False, error="Internal server error.")
     
-    def get_extract_status(self, job_id: str) -> ExtractResponse[Any]:
+    def get_extract_status(self, job_id: str) -> V1ExtractResponse[Any]:
         """
         Retrieve the status of an extract job.
 
@@ -1915,7 +1933,7 @@ class FirecrawlApp:
             response = self._get_request(f'{self.api_url}/v1/extract/{job_id}', headers)
             if response.status_code == 200:
                 try:
-                    return ExtractResponse(**response.json())
+                    return V1ExtractResponse(**response.json())
                 except:
                     raise Exception(f'Failed to parse Firecrawl response as JSON.')
             else:
@@ -1933,7 +1951,7 @@ class FirecrawlApp:
             allow_external_links: Optional[bool] = False,
             enable_web_search: Optional[bool] = False,
             show_sources: Optional[bool] = False,
-            agent: Optional[Dict[str, Any]] = None) -> ExtractResponse[Any]:
+            agent: Optional[Dict[str, Any]] = None) -> V1ExtractResponse[Any]:
         """
         Initiate an asynchronous extract job.
 
@@ -1983,7 +2001,7 @@ class FirecrawlApp:
             response = self._post_request(f'{self.api_url}/v1/extract', request_data, headers)
             if response.status_code == 200:
                 try:
-                    return ExtractResponse(**response.json())
+                    return V1ExtractResponse(**response.json())
                 except:
                     raise Exception(f'Failed to parse Firecrawl response as JSON.')
             else:
@@ -1998,7 +2016,7 @@ class FirecrawlApp:
             max_urls: Optional[int] = None,
             show_full_text: Optional[bool] = None,
             cache: Optional[bool] = None,
-            experimental_stream: Optional[bool] = None) -> GenerateLLMsTextStatusResponse:
+            experimental_stream: Optional[bool] = None) -> V1GenerateLLMsTextStatusResponse:
         """
         Generate LLMs.txt for a given URL and poll until completion.
 
@@ -2019,7 +2037,7 @@ class FirecrawlApp:
         Raises:
             Exception: If generation fails
         """
-        params = GenerateLLMsTextParams(
+        params = V1GenerateLLMsTextParams(
             maxUrls=max_urls,
             showFullText=show_full_text,
             cache=cache,
@@ -2035,7 +2053,7 @@ class FirecrawlApp:
         )
         
         if not response.success or not response.id:
-            return GenerateLLMsTextStatusResponse(
+            return V1GenerateLLMsTextStatusResponse(
                 success=False,
                 error='Failed to start LLMs.txt generation',
                 status='failed',
@@ -2051,7 +2069,7 @@ class FirecrawlApp:
             elif status.status == 'failed':
                 return status
             elif status.status != 'processing':
-                return GenerateLLMsTextStatusResponse(
+                return V1GenerateLLMsTextStatusResponse(
                     success=False,
                     error='LLMs.txt generation job terminated unexpectedly',
                     status='failed',
@@ -2067,7 +2085,7 @@ class FirecrawlApp:
             max_urls: Optional[int] = None,
             show_full_text: Optional[bool] = None,
             cache: Optional[bool] = None,
-            experimental_stream: Optional[bool] = None) -> GenerateLLMsTextResponse:
+            experimental_stream: Optional[bool] = None) -> V1GenerateLLMsTextResponse:
         """
         Initiate an asynchronous LLMs.txt generation operation.
 
@@ -2087,7 +2105,7 @@ class FirecrawlApp:
         Raises:
             Exception: If the generation job initiation fails.
         """
-        params = GenerateLLMsTextParams(
+        params = V1GenerateLLMsTextParams(
             maxUrls=max_urls,
             showFullText=show_full_text,
             cache=cache,
@@ -2095,7 +2113,7 @@ class FirecrawlApp:
         )
 
         headers = self._prepare_headers()
-        json_data = {'url': url, **params.dict(exclude_none=True)}
+        json_data = {'url': url, **params.dict(by_alias=True, exclude_none=True)}
         json_data['origin'] = f"python-sdk@{version}"
 
         try:
@@ -2105,7 +2123,7 @@ class FirecrawlApp:
             print("response", response)
             if response.get('success'):
                 try:
-                    return GenerateLLMsTextResponse(**response)
+                    return V1GenerateLLMsTextResponse(**response)
                 except:
                     raise Exception('Failed to parse Firecrawl response as JSON.')
             else:
@@ -2113,12 +2131,12 @@ class FirecrawlApp:
         except Exception as e:
             raise ValueError(str(e))
 
-        return GenerateLLMsTextResponse(
+        return V1GenerateLLMsTextResponse(
             success=False,
             error='Internal server error'
         )
 
-    def check_generate_llms_text_status(self, id: str) -> GenerateLLMsTextStatusResponse:
+    def check_generate_llms_text_status(self, id: str) -> V1GenerateLLMsTextStatusResponse:
         """
         Check the status of a LLMs.txt generation operation.
 
@@ -2144,7 +2162,7 @@ class FirecrawlApp:
             if response.status_code == 200:
                 try:
                     json_data = response.json()
-                    return GenerateLLMsTextStatusResponse(**json_data)
+                    return V1GenerateLLMsTextStatusResponse(**json_data)
                 except Exception as e:
                     raise Exception(f'Failed to parse Firecrawl response as GenerateLLMsTextStatusResponse: {str(e)}')
             elif response.status_code == 404:
@@ -2154,7 +2172,7 @@ class FirecrawlApp:
         except Exception as e:
             raise ValueError(str(e))
 
-        return GenerateLLMsTextStatusResponse(success=False, error='Internal server error', status='failed', expiresAt='')
+        return V1GenerateLLMsTextStatusResponse(success=False, error='Internal server error', status='failed', expiresAt='')
 
     def _prepare_headers(
             self,
@@ -2204,7 +2222,7 @@ class FirecrawlApp:
             requests.RequestException: If the request fails after the specified retries.
         """
         for attempt in range(retries):
-            response = requests.post(url, headers=headers, json=data, timeout=((data["timeout"] + 5000) if "timeout" in data else None))
+            response = requests.post(url, headers=headers, json=data, timeout=((data["timeout"] / 1000.0 + 5) if "timeout" in data and data["timeout"] is not None else None))
             if response.status_code == 502:
                 time.sleep(backoff_factor * (2 ** attempt))
             else:
@@ -2273,7 +2291,7 @@ class FirecrawlApp:
             self,
             id: str,
             headers: Dict[str, str],
-            poll_interval: int) -> CrawlStatusResponse:
+            poll_interval: int) -> V1CrawlStatusResponse:
         """
         Monitor the status of a crawl job until completion.
 
@@ -2310,7 +2328,7 @@ class FirecrawlApp:
                                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
                             data.extend(status_data.get('data', []))
                         status_data['data'] = data
-                        return CrawlStatusResponse(**status_data)
+                        return V1CrawlStatusResponse(**status_data)
                     else:
                         raise Exception('Crawl job completed but no data was returned')
                 elif status_data['status'] in ['active', 'paused', 'pending', 'queued', 'waiting', 'scraping']:
@@ -2336,10 +2354,22 @@ class FirecrawlApp:
             Exception: An exception with a message containing the status code and error details from the response.
         """
         try:
-            error_message = response.json().get('error', 'No error message provided.')
-            error_details = response.json().get('details', 'No additional error details provided.')
+            response_json = response.json()
+            error_message = response_json.get('error', 'No error message provided.')
+            error_details = response_json.get('details', 'No additional error details provided.')
         except:
-            raise requests.exceptions.HTTPError(f'Failed to parse Firecrawl error response as JSON. Status code: {response.status_code}', response=response)
+            # If we can't parse JSON, provide a helpful error message with response content
+            try:
+                response_text = response.text[:500]  # Limit to first 500 chars
+                if response_text.strip():
+                    error_message = f"Server returned non-JSON response: {response_text}"
+                    error_details = f"Full response status: {response.status_code}"
+                else:
+                    error_message = f"Server returned empty response with status {response.status_code}"
+                    error_details = "No additional details available"
+            except ValueError:
+                error_message = f"Server returned unreadable response with status {response.status_code}"
+                error_details = "No additional details available"
         
         message = self._get_error_message(response.status_code, action, error_message, error_details)
 
@@ -2362,7 +2392,7 @@ class FirecrawlApp:
         if status_code == 402:
             return f"Payment Required: Failed to {action}. {error_message} - {error_details}"
         elif status_code == 403:
-            message = f"Website Not Supported: Failed to {action}. {error_message} - {error_details}"
+            return f"Website Not Supported: Failed to {action}. {error_message} - {error_details}"
         elif status_code == 408:
             return f"Request Timeout: Failed to {action} as the request timed out. {error_message} - {error_details}"
         elif status_code == 409:
@@ -2383,7 +2413,7 @@ class FirecrawlApp:
             system_prompt: Optional[str] = None,
             __experimental_stream_steps: Optional[bool] = None,
             on_activity: Optional[Callable[[Dict[str, Any]], None]] = None,
-            on_source: Optional[Callable[[Dict[str, Any]], None]] = None) -> DeepResearchStatusResponse:
+            on_source: Optional[Callable[[Dict[str, Any]], None]] = None) -> V1DeepResearchStatusResponse:
         """
         Initiates a deep research operation on a given query and polls until completion.
 
@@ -2425,7 +2455,7 @@ class FirecrawlApp:
             research_params['systemPrompt'] = system_prompt
         if __experimental_stream_steps is not None:
             research_params['__experimental_streamSteps'] = __experimental_stream_steps
-        research_params = DeepResearchParams(**research_params)
+        research_params = V1DeepResearchParams(**research_params)
 
         response = self.async_deep_research(
             query,
@@ -2512,11 +2542,11 @@ class FirecrawlApp:
             research_params['systemPrompt'] = system_prompt
         if __experimental_stream_steps is not None:
             research_params['__experimental_streamSteps'] = __experimental_stream_steps
-        research_params = DeepResearchParams(**research_params)
+        research_params = V1DeepResearchParams(**research_params)
 
         headers = self._prepare_headers()
         
-        json_data = {'query': query, **research_params.dict(exclude_none=True)}
+        json_data = {'query': query, **research_params.dict(by_alias=True, exclude_none=True)}
         json_data['origin'] = f"python-sdk@{version}"
 
         # Handle json options schema if present
@@ -2539,7 +2569,7 @@ class FirecrawlApp:
 
         return {'success': False, 'error': 'Internal server error'}
 
-    def check_deep_research_status(self, id: str) -> DeepResearchStatusResponse:
+    def check_deep_research_status(self, id: str) -> V1DeepResearchStatusResponse:
         """
         Check the status of a deep research operation.
 
@@ -2650,19 +2680,19 @@ class FirecrawlApp:
             return [self._ensure_schema_dict(v) for v in schema]
         return schema
 
-class CrawlWatcher:
+class V1CrawlWatcher:
     """
     A class to watch and handle crawl job events via WebSocket connection.
 
     Attributes:
         id (str): The ID of the crawl job to watch
-        app (FirecrawlApp): The FirecrawlApp instance
+        app (V1FirecrawlApp): The V1FirecrawlApp instance
         data (List[Dict[str, Any]]): List of crawled documents/data
         status (str): Current status of the crawl job
         ws_url (str): WebSocket URL for the crawl job
         event_handlers (dict): Dictionary of event type to list of handler functions
     """
-    def __init__(self, id: str, app: FirecrawlApp):
+    def __init__(self, id: str, app: V1FirecrawlApp):
         self.id = id
         self.app = app
         self.data: List[Dict[str, Any]] = []
@@ -2741,12 +2771,16 @@ class CrawlWatcher:
             self.data.append(msg['data'])
             self.dispatch_event('document', {'data': msg['data'], 'id': self.id})
 
-class AsyncFirecrawlApp(FirecrawlApp):
+class AsyncV1FirecrawlApp(V1FirecrawlApp):
     """
-    Asynchronous version of FirecrawlApp that implements async methods using aiohttp.
-    Provides non-blocking alternatives to all FirecrawlApp operations.
+    Asynchronous version of V1FirecrawlApp that implements async methods using aiohttp.
+    Provides non-blocking alternatives to all V1FirecrawlApp operations.
     """
 
+    def __init__(self, api_key: str, api_url: str = "https://api.firecrawl.dev"):
+        # Reuse V1 helpers (_prepare_headers, _validate_kwargs, _ensure_schema_dict, _get_error_message)
+        super().__init__(api_key=api_key, api_url=api_url)
+
     async def _async_request(
             self,
             method: str,
@@ -2882,14 +2916,14 @@ class AsyncFirecrawlApp(FirecrawlApp):
     async def crawl_url_and_watch(
             self,
             url: str,
-            params: Optional[CrawlParams] = None,
-            idempotency_key: Optional[str] = None) -> 'AsyncCrawlWatcher':
+            params: Optional[V1CrawlParams] = None,
+            idempotency_key: Optional[str] = None) -> 'AsyncV1CrawlWatcher':
         """
-        Initiate an async crawl job and return an AsyncCrawlWatcher to monitor progress via WebSocket.
+        Initiate an async crawl job and return an AsyncV1CrawlWatcher to monitor progress via WebSocket.
 
         Args:
           url (str): Target URL to start crawling from
-          params (Optional[CrawlParams]): See CrawlParams model for configuration:
+          params (Optional[V1CrawlParams]): See V1CrawlParams model for configuration:
             URL Discovery:
             * includePaths - Patterns of URLs to include
             * excludePaths - Patterns of URLs to exclude
@@ -2912,28 +2946,28 @@ class AsyncFirecrawlApp(FirecrawlApp):
           idempotency_key (Optional[str]): Unique key to prevent duplicate requests
 
         Returns:
-          AsyncCrawlWatcher: An instance to monitor the crawl job via WebSocket
+          AsyncV1CrawlWatcher: An instance to monitor the crawl job via WebSocket
 
         Raises:
           Exception: If crawl job fails to start
         """
         crawl_response = await self.async_crawl_url(url, params, idempotency_key)
         if crawl_response.get('success') and 'id' in crawl_response:
-            return AsyncCrawlWatcher(crawl_response['id'], self)
+            return AsyncV1CrawlWatcher(crawl_response['id'], self)
         else:
             raise Exception("Crawl job failed to start")
 
     async def batch_scrape_urls_and_watch(
             self,
             urls: List[str],
-            params: Optional[ScrapeParams] = None,
-            idempotency_key: Optional[str] = None) -> 'AsyncCrawlWatcher':
+            params: Optional[V1ScrapeParams] = None,
+            idempotency_key: Optional[str] = None) -> 'AsyncV1CrawlWatcher':
         """
-        Initiate an async batch scrape job and return an AsyncCrawlWatcher to monitor progress.
+        Initiate an async batch scrape job and return an AsyncV1CrawlWatcher to monitor progress.
 
         Args:
             urls (List[str]): List of URLs to scrape
-            params (Optional[ScrapeParams]): See ScrapeParams model for configuration:
+            params (Optional[V1ScrapeParams]): See V1ScrapeParams model for configuration:
 
               Content Options:
               * formats - Content formats to retrieve
@@ -2954,14 +2988,14 @@ class AsyncFirecrawlApp(FirecrawlApp):
             idempotency_key (Optional[str]): Unique key to prevent duplicate requests
 
         Returns:
-            AsyncCrawlWatcher: An instance to monitor the batch scrape job via WebSocket
+            AsyncV1CrawlWatcher: An instance to monitor the batch scrape job via WebSocket
 
         Raises:
             Exception: If batch scrape job fails to start
         """
         batch_response = await self.async_batch_scrape_urls(urls, params, idempotency_key)
         if batch_response.get('success') and 'id' in batch_response:
-            return AsyncCrawlWatcher(batch_response['id'], self)
+            return AsyncV1CrawlWatcher(batch_response['id'], self)
         else:
             raise Exception("Batch scrape job failed to start")
 
@@ -2975,18 +3009,18 @@ class AsyncFirecrawlApp(FirecrawlApp):
             exclude_tags: Optional[List[str]] = None,
             only_main_content: Optional[bool] = None,
             wait_for: Optional[int] = None,
-            timeout: Optional[int] = None,
-            location: Optional[LocationConfig] = None,
+            timeout: Optional[int] = 30000,
+            location: Optional[V1LocationConfig] = None,
             mobile: Optional[bool] = None,
             skip_tls_verification: Optional[bool] = None,
             remove_base64_images: Optional[bool] = None,
             block_ads: Optional[bool] = None,
             proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
             parse_pdf: Optional[bool] = None,
-            extract: Optional[JsonConfig] = None,
-            json_options: Optional[JsonConfig] = None,
-            actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-            **kwargs) -> ScrapeResponse[Any]:
+            extract: Optional[V1JsonConfig] = None,
+            json_options: Optional[V1JsonConfig] = None,
+            actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+            **kwargs) -> V1ScrapeResponse[Any]:
         """
         Scrape a single URL asynchronously.
 
@@ -2999,19 +3033,19 @@ class AsyncFirecrawlApp(FirecrawlApp):
           only_main_content (Optional[bool]): Extract main content only
           wait_for (Optional[int]): Wait for a specific element to appear
           timeout (Optional[int]): Request timeout (ms)
-          location (Optional[LocationConfig]): Location configuration
+          location (Optional[V1LocationConfig]): Location configuration
           mobile (Optional[bool]): Use mobile user agent
           skip_tls_verification (Optional[bool]): Skip TLS verification
           remove_base64_images (Optional[bool]): Remove base64 images
           block_ads (Optional[bool]): Block ads
           proxy (Optional[Literal["basic", "stealth", "auto"]]): Proxy type (basic/stealth)
-          extract (Optional[JsonConfig]): Content extraction settings
-          json_options (Optional[JsonConfig]): JSON extraction settings
-          actions (Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]]): Actions to perform
+          extract (Optional[V1JsonConfig]): Content extraction settings
+          json_options (Optional[V1JsonConfig]): JSON extraction settings
+          actions (Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]]): Actions to perform
           **kwargs: Additional parameters to pass to the API
 
         Returns:
-            ScrapeResponse with:
+            V1ScrapeResponse with:
             * success - Whether scrape was successful
             * markdown - Markdown content if requested
             * html - HTML content if requested
@@ -3052,7 +3086,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if timeout:
             scrape_params['timeout'] = timeout
         if location:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -3069,14 +3103,14 @@ class AsyncFirecrawlApp(FirecrawlApp):
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
         if actions:
-            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(exclude_none=True) for action in actions]
+            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(by_alias=True, exclude_none=True) for action in actions]
         if 'extract' in scrape_params and scrape_params['extract'] and 'schema' in scrape_params['extract']:
             scrape_params['extract']['schema'] = self._ensure_schema_dict(scrape_params['extract']['schema'])
         if 'jsonOptions' in scrape_params and scrape_params['jsonOptions'] and 'schema' in scrape_params['jsonOptions']:
@@ -3091,7 +3125,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         )
 
         if response.get('success') and 'data' in response:
-            return ScrapeResponse(**response['data'])
+            return V1ScrapeResponse(**response['data'])
         elif "error" in response:
             raise Exception(f'Failed to scrape URL. Error: {response["error"]}')
         else:
@@ -3109,21 +3143,21 @@ class AsyncFirecrawlApp(FirecrawlApp):
         exclude_tags: Optional[List[str]] = None,
         only_main_content: Optional[bool] = None,
         wait_for: Optional[int] = None,
-        timeout: Optional[int] = None,
-        location: Optional[LocationConfig] = None,
+        timeout: Optional[int] = 30000,
+        location: Optional[V1LocationConfig] = None,
         mobile: Optional[bool] = None,
         skip_tls_verification: Optional[bool] = None,
         remove_base64_images: Optional[bool] = None,
         block_ads: Optional[bool] = None,
         proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
-        extract: Optional[JsonConfig] = None,
-        json_options: Optional[JsonConfig] = None,
-        actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-        agent: Optional[AgentOptions] = None,
+        extract: Optional[V1JsonConfig] = None,
+        json_options: Optional[V1JsonConfig] = None,
+        actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+        agent: Optional[V1AgentOptions] = None,
         poll_interval: Optional[int] = 2,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> BatchScrapeStatusResponse:
+    ) -> V1BatchScrapeStatusResponse:
         """
         Asynchronously scrape multiple URLs and monitor until completion.
 
@@ -3151,7 +3185,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            BatchScrapeStatusResponse with:
+            V1BatchScrapeStatusResponse with:
             * Scraping status and progress
             * Scraped content for each URL
             * Success/error information
@@ -3180,7 +3214,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if timeout is not None:
             scrape_params['timeout'] = timeout
         if location is not None:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -3195,22 +3229,23 @@ class AsyncFirecrawlApp(FirecrawlApp):
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
-
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
+        if actions is not None:
+            scrape_params['actions'] = [action.dict(by_alias=True, exclude_none=True) for action in actions]
         if agent is not None:
-            scrape_params['agent'] = agent.dict(exclude_none=True)
+            scrape_params['agent'] = agent.dict(by_alias=True, exclude_none=True)
 
         # Add any additional kwargs
         scrape_params.update(kwargs)
 
         # Create final params object
-        final_params = ScrapeParams(**scrape_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1ScrapeParams(**scrape_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -3247,21 +3282,21 @@ class AsyncFirecrawlApp(FirecrawlApp):
         exclude_tags: Optional[List[str]] = None,
         only_main_content: Optional[bool] = None,
         wait_for: Optional[int] = None,
-        timeout: Optional[int] = None,
-        location: Optional[LocationConfig] = None,
+        timeout: Optional[int] = 30000,
+        location: Optional[V1LocationConfig] = None,
         mobile: Optional[bool] = None,
         skip_tls_verification: Optional[bool] = None,
         remove_base64_images: Optional[bool] = None,
         block_ads: Optional[bool] = None,
         proxy: Optional[Literal["basic", "stealth", "auto"]] = None,
-        extract: Optional[JsonConfig] = None,
-        json_options: Optional[JsonConfig] = None,
-        actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction, PDFAction]]] = None,
-        agent: Optional[AgentOptions] = None,
+        extract: Optional[V1JsonConfig] = None,
+        json_options: Optional[V1JsonConfig] = None,
+        actions: Optional[List[Union[V1WaitAction, V1ScreenshotAction, V1ClickAction, V1WriteAction, V1PressAction, V1ScrollAction, V1ScrapeAction, V1ExecuteJavascriptAction, V1PDFAction]]] = None,
+        agent: Optional[V1AgentOptions] = None,
         zero_data_retention: Optional[bool] = None,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> BatchScrapeResponse:
+    ) -> V1BatchScrapeResponse:
         """
         Initiate a batch scrape job asynchronously.
 
@@ -3289,7 +3324,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            BatchScrapeResponse with:
+            V1BatchScrapeResponse with:
             * success - Whether job started successfully
             * id - Unique identifier for the job
             * url - Status check URL
@@ -3319,7 +3354,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if timeout is not None:
             scrape_params['timeout'] = timeout
         if location is not None:
-            scrape_params['location'] = location.dict(exclude_none=True)
+            scrape_params['location'] = location.dict(by_alias=True, exclude_none=True)
         if mobile is not None:
             scrape_params['mobile'] = mobile
         if skip_tls_verification is not None:
@@ -3334,16 +3369,16 @@ class AsyncFirecrawlApp(FirecrawlApp):
             extract = self._ensure_schema_dict(extract)
             if isinstance(extract, dict) and "schema" in extract:
                 extract["schema"] = self._ensure_schema_dict(extract["schema"])
-            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(by_alias=True, exclude_none=True)
         if json_options is not None:
             json_options = self._ensure_schema_dict(json_options)
             if isinstance(json_options, dict) and "schema" in json_options:
                 json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
-            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(by_alias=True, exclude_none=True)
         if actions:
-            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(exclude_none=True) for action in actions]
+            scrape_params['actions'] = [action if isinstance(action, dict) else action.dict(by_alias=True, exclude_none=True) for action in actions]
         if agent is not None:
-            scrape_params['agent'] = agent.dict(exclude_none=True)
+            scrape_params['agent'] = agent.dict(by_alias=True, exclude_none=True)
         if zero_data_retention is not None:
             scrape_params['zeroDataRetention'] = zero_data_retention
         
@@ -3351,8 +3386,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
         scrape_params.update(kwargs)
 
         # Create final params object
-        final_params = ScrapeParams(**scrape_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1ScrapeParams(**scrape_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -3371,7 +3406,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
 
         if response.get('status_code') == 200:
             try:
-                return BatchScrapeResponse(**response.json())
+                return V1BatchScrapeResponse(**response.json())
             except:
                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
         else:
@@ -3390,8 +3425,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
         crawl_entire_domain: Optional[bool] = None,
         allow_external_links: Optional[bool] = None,
         ignore_sitemap: Optional[bool] = None,
-        scrape_options: Optional[ScrapeOptions] = None,
-        webhook: Optional[Union[str, WebhookConfig]] = None,
+        scrape_options: Optional[V1ScrapeOptions] = None,
+        webhook: Optional[Union[str, V1WebhookConfig]] = None,
         deduplicate_similar_urls: Optional[bool] = None,
         ignore_query_parameters: Optional[bool] = None,
         regex_on_full_url: Optional[bool] = None,
@@ -3400,7 +3435,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         poll_interval: Optional[int] = 2,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> CrawlStatusResponse:
+    ) -> V1CrawlStatusResponse:
         """
         Crawl a website starting from a URL.
 
@@ -3415,8 +3450,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
             crawl_entire_domain (Optional[bool]): Follow parent directory links
             allow_external_links (Optional[bool]): Follow external domain links
             ignore_sitemap (Optional[bool]): Skip sitemap.xml processing
-            scrape_options (Optional[ScrapeOptions]): Page scraping configuration
-            webhook (Optional[Union[str, WebhookConfig]]): Notification webhook settings
+            scrape_options (Optional[V1ScrapeOptions]): Page scraping configuration
+            webhook (Optional[Union[str, V1WebhookConfig]]): Notification webhook settings
             deduplicate_similar_urls (Optional[bool]): Remove similar URLs
             ignore_query_parameters (Optional[bool]): Ignore URL parameters
             regex_on_full_url (Optional[bool]): Apply regex to full URLs
@@ -3427,7 +3462,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            CrawlStatusResponse with:
+            V1CrawlStatusResponse with:
             * Crawling status and progress
             * Crawled page contents
             * Success/error information
@@ -3460,7 +3495,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if ignore_sitemap is not None:
             crawl_params['ignoreSitemap'] = ignore_sitemap
         if scrape_options is not None:
-            crawl_params['scrapeOptions'] = scrape_options.dict(exclude_none=True)
+            crawl_params['scrapeOptions'] = scrape_options.dict(by_alias=True, exclude_none=True)
         if webhook is not None:
             crawl_params['webhook'] = webhook
         if deduplicate_similar_urls is not None:
@@ -3478,8 +3513,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
         crawl_params.update(kwargs)
 
         # Create final params object
-        final_params = CrawlParams(**crawl_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1CrawlParams(**crawl_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['url'] = url
         params_dict['origin'] = f"python-sdk@{version}"
         # Make request
@@ -3510,8 +3545,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
         crawl_entire_domain: Optional[bool] = None,
         allow_external_links: Optional[bool] = None,
         ignore_sitemap: Optional[bool] = None,
-        scrape_options: Optional[ScrapeOptions] = None,
-        webhook: Optional[Union[str, WebhookConfig]] = None,
+        scrape_options: Optional[V1ScrapeOptions] = None,
+        webhook: Optional[Union[str, V1WebhookConfig]] = None,
         deduplicate_similar_urls: Optional[bool] = None,
         ignore_query_parameters: Optional[bool] = None,
         regex_on_full_url: Optional[bool] = None,
@@ -3520,7 +3555,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         poll_interval: Optional[int] = 2,
         idempotency_key: Optional[str] = None,
         **kwargs
-    ) -> CrawlResponse:
+    ) -> V1CrawlResponse:
         """
         Start an asynchronous crawl job.
 
@@ -3544,7 +3579,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            CrawlResponse with:
+            V1CrawlResponse with:
             * success - Whether crawl started successfully
             * id - Unique identifier for the crawl job
             * url - Status check URL for the crawl
@@ -3575,7 +3610,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if ignore_sitemap is not None:
             crawl_params['ignoreSitemap'] = ignore_sitemap
         if scrape_options is not None:
-            crawl_params['scrapeOptions'] = scrape_options.dict(exclude_none=True)
+            crawl_params['scrapeOptions'] = scrape_options.dict(by_alias=True, exclude_none=True)
         if webhook is not None:
             crawl_params['webhook'] = webhook
         if deduplicate_similar_urls is not None:
@@ -3593,8 +3628,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
         crawl_params.update(kwargs)
 
         # Create final params object
-        final_params = CrawlParams(**crawl_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1CrawlParams(**crawl_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['url'] = url
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -3608,13 +3643,13 @@ class AsyncFirecrawlApp(FirecrawlApp):
 
         if response.get('success'):
             try:
-                return CrawlResponse(**response)
+                return V1CrawlResponse(**response)
             except:
                 raise Exception(f'Failed to parse Firecrawl response as JSON.')
         else:
             await self._handle_error(response, 'start crawl job')
 
-    async def check_crawl_status(self, id: str) -> CrawlStatusResponse:
+    async def check_crawl_status(self, id: str) -> V1CrawlStatusResponse:
         """
         Check the status and results of an asynchronous crawl job.
 
@@ -3622,7 +3657,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             id (str): Unique identifier for the crawl job
 
         Returns:
-            CrawlStatusResponse containing:
+            V1CrawlStatusResponse containing:
             Status Information:
             * status - Current state (scraping/completed/failed/cancelled)
             * completed - Number of pages crawled
@@ -3661,8 +3696,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
                     data.extend(next_data.get('data', []))
                     status_data = next_data
                 status_data['data'] = data
-        # Create CrawlStatusResponse object from status data
-        response = CrawlStatusResponse(
+        # Create V1CrawlStatusResponse object from status data
+        response = V1CrawlStatusResponse(
             status=status_data.get('status'),
             total=status_data.get('total'),
             completed=status_data.get('completed'),
@@ -3680,7 +3715,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
 
         return response
 
-    async def _async_monitor_job_status(self, id: str, headers: Dict[str, str], poll_interval: int = 2) -> CrawlStatusResponse:
+    async def _async_monitor_job_status(self, id: str, headers: Dict[str, str], poll_interval: int = 2) -> V1CrawlStatusResponse:
         """
         Monitor the status of an asynchronous job until completion.
 
@@ -3690,7 +3725,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             poll_interval (int): Seconds between status checks (default: 2)
 
         Returns:
-            CrawlStatusResponse: The job results if completed successfully
+            V1CrawlStatusResponse: The job results if completed successfully
 
         Raises:
             Exception: If the job fails or an error occurs during status checks
@@ -3715,7 +3750,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
                         data.extend(next_data.get('data', []))
                         status_data = next_data
                     status_data['data'] = data
-                    return CrawlStatusResponse(**status_data)
+                    return V1CrawlStatusResponse(**status_data)
                 else:
                     raise Exception('Job completed but no data was returned')
             elif status_data.get('status') in ['active', 'paused', 'pending', 'queued', 'waiting', 'scraping']:
@@ -3732,14 +3767,14 @@ class AsyncFirecrawlApp(FirecrawlApp):
         include_subdomains: Optional[bool] = None,
         sitemap_only: Optional[bool] = None,
         limit: Optional[int] = None,
-        timeout: Optional[int] = None,
-        params: Optional[MapParams] = None) -> MapResponse:
+        timeout: Optional[int] = 30000,
+        params: Optional[V1MapParams] = None) -> V1MapResponse:
         """
         Asynchronously map and discover links from a URL.
 
         Args:
           url (str): Target URL to map
-          params (Optional[MapParams]): See MapParams model:
+          params (Optional[V1MapParams]): See V1MapParams model:
             Discovery Options:
             * search - Filter pattern for URLs
             * ignoreSitemap - Skip sitemap.xml
@@ -3751,7 +3786,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             * timeout - Request timeout (ms)
 
         Returns:
-          MapResponse with:
+          V1MapResponse with:
           * Discovered URLs
           * Success/error status
 
@@ -3760,7 +3795,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         """
         map_params = {}
         if params:
-            map_params.update(params.dict(exclude_none=True))
+            map_params.update(params.dict(by_alias=True, exclude_none=True))
 
         # Add individual parameters
         if search is not None:
@@ -3777,8 +3812,8 @@ class AsyncFirecrawlApp(FirecrawlApp):
             map_params['timeout'] = timeout
 
         # Create final params object
-        final_params = MapParams(**map_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1MapParams(**map_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['url'] = url
         params_dict['origin'] = f"python-sdk@{version}"
 
@@ -3791,7 +3826,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         )
 
         if response.get('success') and 'links' in response:
-            return MapResponse(**response)
+            return V1MapResponse(**response)
         elif 'error' in response:
             raise Exception(f'Failed to map URL. Error: {response["error"]}')
         else:
@@ -3807,7 +3842,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             allow_external_links: Optional[bool] = False,
             enable_web_search: Optional[bool] = False,
             show_sources: Optional[bool] = False,
-            agent: Optional[Dict[str, Any]] = None) -> ExtractResponse[Any]:
+            agent: Optional[Dict[str, Any]] = None) -> V1ExtractResponse[Any]:
             
         """
         Asynchronously extract structured information from URLs.
@@ -3823,7 +3858,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             agent (Optional[Dict[str, Any]]): Agent configuration
 
         Returns:
-          ExtractResponse with:
+          V1ExtractResponse with:
           * Structured data matching schema
           * Source information if requested
           * Success/error status
@@ -3878,7 +3913,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
                 )
 
                 if status_data['status'] == 'completed':
-                    return ExtractResponse(**status_data)
+                    return V1ExtractResponse(**status_data)
                 elif status_data['status'] in ['failed', 'cancelled']:
                     raise Exception(f'Extract job {status_data["status"]}. Error: {status_data["error"]}')
 
@@ -3886,7 +3921,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         else:
             raise Exception(f'Failed to extract. Error: {response.get("error")}')
 
-    async def check_batch_scrape_status(self, id: str) -> BatchScrapeStatusResponse:
+    async def check_batch_scrape_status(self, id: str) -> V1BatchScrapeStatusResponse:
         """
         Check the status of an asynchronous batch scrape job.
 
@@ -3894,7 +3929,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             id (str): The ID of the batch scrape job
 
         Returns:
-            BatchScrapeStatusResponse containing:
+            V1BatchScrapeStatusResponse containing:
             Status Information:
             * status - Current state (scraping/completed/failed/cancelled)
             * completed - Number of URLs scraped
@@ -3934,7 +3969,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
                     status_data = next_data
                 status_data['data'] = data
 
-        response = BatchScrapeStatusResponse(
+        response = V1BatchScrapeStatusResponse(
             status=status_data.get('status'),
             total=status_data.get('total'),
             completed=status_data.get('completed'),
@@ -3954,7 +3989,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             **response
         }
 
-    async def check_batch_scrape_errors(self, id: str) -> CrawlErrorsResponse:
+    async def check_batch_scrape_errors(self, id: str) -> V1CrawlErrorsResponse:
         """
         Get information about errors from an asynchronous batch scrape job.
 
@@ -3962,7 +3997,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
           id (str): The ID of the batch scrape job
 
         Returns:
-          CrawlErrorsResponse containing:
+          V1CrawlErrorsResponse containing:
             errors (List[Dict[str, str]]): List of errors with fields:
               * id (str): Error ID
               * timestamp (str): When the error occurred
@@ -3979,7 +4014,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             headers
         )
 
-    async def check_crawl_errors(self, id: str) -> CrawlErrorsResponse:
+    async def check_crawl_errors(self, id: str) -> V1CrawlErrorsResponse:
         """
         Get information about errors from an asynchronous crawl job.
 
@@ -3987,7 +4022,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             id (str): The ID of the crawl job
 
         Returns:
-            CrawlErrorsResponse containing:
+            V1CrawlErrorsResponse containing:
             * errors (List[Dict[str, str]]): List of errors with fields:
                 - id (str): Error ID
                 - timestamp (str): When the error occurred
@@ -4024,7 +4059,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             async with session.delete(f'{self.api_url}/v1/crawl/{id}', headers=headers) as response:
                 return await response.json()
 
-    async def get_extract_status(self, job_id: str) -> ExtractResponse[Any]:
+    async def get_extract_status(self, job_id: str) -> V1ExtractResponse[Any]:
         """
         Check the status of an asynchronous extraction job.
 
@@ -4032,7 +4067,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             job_id (str): The ID of the extraction job
 
         Returns:
-            ExtractResponse[Any] with:
+            V1ExtractResponse[Any] with:
             * success (bool): Whether request succeeded
             * data (Optional[Any]): Extracted data matching schema
             * error (Optional[str]): Error message if any
@@ -4061,7 +4096,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             allow_external_links: Optional[bool] = False,
             enable_web_search: Optional[bool] = False,
             show_sources: Optional[bool] = False,
-            agent: Optional[Dict[str, Any]] = None) -> ExtractResponse[Any]:
+            agent: Optional[Dict[str, Any]] = None) -> V1ExtractResponse[Any]:
         """
         Initiate an asynchronous extraction job without waiting for completion.
 
@@ -4077,7 +4112,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             idempotency_key (Optional[str]): Unique key to prevent duplicate requests
 
         Returns:
-            ExtractResponse[Any] with:
+            V1ExtractResponse[Any] with:
             * success (bool): Whether request succeeded
             * data (Optional[Any]): Extracted data matching schema
             * error (Optional[str]): Error message if any
@@ -4096,7 +4131,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if schema:
             schema = self._ensure_schema_dict(schema)
 
-        request_data = ExtractResponse(
+        request_data = V1ExtractResponse(
             urls=urls or [],
             allowExternalLinks=allow_external_links,
             enableWebSearch=enable_web_search,
@@ -4127,7 +4162,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             *,
             max_urls: Optional[int] = None,
             show_full_text: Optional[bool] = None,
-            experimental_stream: Optional[bool] = None) -> GenerateLLMsTextStatusResponse:
+            experimental_stream: Optional[bool] = None) -> V1GenerateLLMsTextStatusResponse:
         """
         Generate LLMs.txt for a given URL and monitor until completion.
 
@@ -4138,7 +4173,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             experimental_stream (Optional[bool]): Enable experimental streaming
 
         Returns:
-            GenerateLLMsTextStatusResponse containing:
+            V1GenerateLLMsTextStatusResponse containing:
             * success (bool): Whether generation completed successfully
             * status (str): Status of generation (processing/completed/failed)
             * data (Dict[str, str], optional): Generated text with fields:
@@ -4162,7 +4197,6 @@ class AsyncFirecrawlApp(FirecrawlApp):
             url,
             max_urls=max_urls,
             show_full_text=show_full_text,
-            cache=cache,
             experimental_stream=experimental_stream
         )
         if not response.get('success') or 'id' not in response:
@@ -4181,7 +4215,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
 
             await asyncio.sleep(2)
 
-        return GenerateLLMsTextStatusResponse(success=False, error='LLMs.txt generation job terminated unexpectedly')
+        return V1GenerateLLMsTextStatusResponse(success=False, error='LLMs.txt generation job terminated unexpectedly', status='failed', expiresAt='')
 
     async def async_generate_llms_text(
             self,
@@ -4190,7 +4224,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             max_urls: Optional[int] = None,
             show_full_text: Optional[bool] = None,
             cache: Optional[bool] = None,
-            experimental_stream: Optional[bool] = None) -> GenerateLLMsTextResponse:
+            experimental_stream: Optional[bool] = None) -> V1GenerateLLMsTextResponse:
         """
         Initiate an asynchronous LLMs.txt generation job without waiting for completion.
 
@@ -4202,7 +4236,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             experimental_stream (Optional[bool]): Enable experimental streaming
 
         Returns:
-            GenerateLLMsTextResponse containing:
+            V1GenerateLLMsTextResponse containing:
             * success (bool): Whether job started successfully
             * id (str): Unique identifier for the job
             * error (str, optional): Error message if start failed
@@ -4218,7 +4252,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if experimental_stream is not None:
             params['__experimental_stream'] = experimental_stream
 
-        params = GenerateLLMsTextParams(
+        params = V1GenerateLLMsTextParams(
             maxUrls=max_urls,
             showFullText=show_full_text,
             cache=cache,
@@ -4226,7 +4260,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         )
 
         headers = self._prepare_headers()
-        json_data = {'url': url, **params.dict(exclude_none=True)}
+        json_data = {'url': url, **params.dict(by_alias=True, exclude_none=True)}
         json_data['origin'] = f"python-sdk@{version}"
 
         try:
@@ -4238,7 +4272,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         except Exception as e:
             raise ValueError(str(e))
 
-    async def check_generate_llms_text_status(self, id: str) -> GenerateLLMsTextStatusResponse:
+    async def check_generate_llms_text_status(self, id: str) -> V1GenerateLLMsTextStatusResponse:
         """
         Check the status of an asynchronous LLMs.txt generation job.
 
@@ -4246,7 +4280,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             id (str): The ID of the generation job
 
         Returns:
-            GenerateLLMsTextStatusResponse containing:
+            V1GenerateLLMsTextStatusResponse containing:
             * success (bool): Whether generation completed successfully
             * status (str): Status of generation (processing/completed/failed)
             * data (Dict[str, str], optional): Generated text with fields:
@@ -4278,7 +4312,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             system_prompt: Optional[str] = None,
             __experimental_stream_steps: Optional[bool] = None,
             on_activity: Optional[Callable[[Dict[str, Any]], None]] = None,
-            on_source: Optional[Callable[[Dict[str, Any]], None]] = None) -> DeepResearchStatusResponse:
+            on_source: Optional[Callable[[Dict[str, Any]], None]] = None) -> V1DeepResearchStatusResponse:
         """
         Initiates a deep research operation on a given query and polls until completion.
 
@@ -4320,7 +4354,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             research_params['systemPrompt'] = system_prompt
         if __experimental_stream_steps is not None:
             research_params['__experimental_streamSteps'] = __experimental_stream_steps
-        research_params = DeepResearchParams(**research_params)
+        research_params = V1DeepResearchParams(**research_params)
 
         response = await self.async_deep_research(
             query,
@@ -4361,7 +4395,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
 
             await asyncio.sleep(2)
 
-        return DeepResearchStatusResponse(success=False, error='Deep research job terminated unexpectedly')
+        return V1DeepResearchStatusResponse(success=False, error='Deep research job terminated unexpectedly')
 
     async def async_deep_research(
             self,
@@ -4407,11 +4441,11 @@ class AsyncFirecrawlApp(FirecrawlApp):
             research_params['systemPrompt'] = system_prompt
         if __experimental_stream_steps is not None:
             research_params['__experimental_streamSteps'] = __experimental_stream_steps
-        research_params = DeepResearchParams(**research_params)
+        research_params = V1DeepResearchParams(**research_params)
 
         headers = self._prepare_headers()
         
-        json_data = {'query': query, **research_params.dict(exclude_none=True)}
+        json_data = {'query': query, **research_params.dict(by_alias=True, exclude_none=True)}
         json_data['origin'] = f"python-sdk@{version}"
 
         try:
@@ -4423,7 +4457,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
         except Exception as e:
             raise ValueError(str(e))
 
-    async def check_deep_research_status(self, id: str) -> DeepResearchStatusResponse:
+    async def check_deep_research_status(self, id: str) -> V1DeepResearchStatusResponse:
         """
         Check the status of a deep research operation.
 
@@ -4467,10 +4501,10 @@ class AsyncFirecrawlApp(FirecrawlApp):
             lang: Optional[str] = None,
             country: Optional[str] = None,
             location: Optional[str] = None,
-            timeout: Optional[int] = None,
-            scrape_options: Optional[ScrapeOptions] = None,
-            params: Optional[Union[Dict[str, Any], SearchParams]] = None,
-            **kwargs) -> SearchResponse:
+            timeout: Optional[int] = 30000,
+            scrape_options: Optional[V1ScrapeOptions] = None,
+            params: Optional[Union[Dict[str, Any], V1SearchParams]] = None,
+            **kwargs) -> V1SearchResponse:
         """
         Asynchronously search for content using Firecrawl.
 
@@ -4503,7 +4537,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             if isinstance(params, dict):
                 search_params.update(params)
             else:
-                search_params.update(params.dict(exclude_none=True))
+                search_params.update(params.dict(by_alias=True, exclude_none=True))
 
         # Add individual parameters
         if limit is not None:
@@ -4521,14 +4555,14 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if timeout is not None:
             search_params['timeout'] = timeout
         if scrape_options is not None:
-            search_params['scrapeOptions'] = scrape_options.dict(exclude_none=True)
+            search_params['scrapeOptions'] = scrape_options.dict(by_alias=True, exclude_none=True)
         
         # Add any additional kwargs
         search_params.update(kwargs)
 
         # Create final params object
-        final_params = SearchParams(query=query, **search_params)
-        params_dict = final_params.dict(exclude_none=True)
+        final_params = V1SearchParams(query=query, **search_params)
+        params_dict = final_params.dict(by_alias=True, exclude_none=True)
         params_dict['origin'] = f"python-sdk@{version}"
 
         return await self._async_post_request(
@@ -4537,11 +4571,11 @@ class AsyncFirecrawlApp(FirecrawlApp):
             {"Authorization": f"Bearer {self.api_key}"}
         )
 
-class AsyncCrawlWatcher(CrawlWatcher):
+class AsyncV1CrawlWatcher(V1CrawlWatcher):
     """
-    Async version of CrawlWatcher that properly handles async operations.
+    Async version of V1CrawlWatcher that properly handles async operations.
     """
-    def __init__(self, id: str, app: AsyncFirecrawlApp):
+    def __init__(self, id: str, app: AsyncV1FirecrawlApp):
         super().__init__(id, app)
 
     async def connect(self) -> None: