strands-apify 0.1.0__py3-none-any.whl

strands_apify/__init__.py

@@ -0,0 +1,58 @@
+"""Apify web scraping, social media, search and crawling tools for Strands Agents SDK."""
+
+from .core import (
+    APIFY_CORE_TOOLS,
+    apify_get_dataset_items,
+    apify_run_actor,
+    apify_run_actor_and_get_dataset,
+    apify_run_task,
+    apify_run_task_and_get_dataset,
+    apify_scrape_url,
+)
+from .search_crawling import (
+    APIFY_SEARCH_TOOLS,
+    apify_ecommerce_scraper,
+    apify_google_places_scraper,
+    apify_google_search_scraper,
+    apify_website_content_crawler,
+    apify_youtube_scraper,
+)
+from .social_media import (
+    APIFY_SOCIAL_TOOLS,
+    apify_facebook_posts_scraper,
+    apify_instagram_scraper,
+    apify_linkedin_profile_detail,
+    apify_linkedin_profile_posts,
+    apify_linkedin_profile_search,
+    apify_tiktok_scraper,
+    apify_twitter_scraper,
+)
+from .utils import ApifyToolClient
+
+APIFY_ALL_TOOLS = APIFY_CORE_TOOLS + APIFY_SOCIAL_TOOLS + APIFY_SEARCH_TOOLS
+
+__all__ = [
+    "APIFY_ALL_TOOLS",
+    "APIFY_CORE_TOOLS",
+    "APIFY_SEARCH_TOOLS",
+    "APIFY_SOCIAL_TOOLS",
+    "ApifyToolClient",
+    "apify_ecommerce_scraper",
+    "apify_facebook_posts_scraper",
+    "apify_get_dataset_items",
+    "apify_google_places_scraper",
+    "apify_google_search_scraper",
+    "apify_instagram_scraper",
+    "apify_linkedin_profile_detail",
+    "apify_linkedin_profile_posts",
+    "apify_linkedin_profile_search",
+    "apify_run_actor",
+    "apify_run_actor_and_get_dataset",
+    "apify_run_task",
+    "apify_run_task_and_get_dataset",
+    "apify_scrape_url",
+    "apify_tiktok_scraper",
+    "apify_twitter_scraper",
+    "apify_website_content_crawler",
+    "apify_youtube_scraper",
+]

strands_apify/core.py

@@ -0,0 +1,331 @@
+"""Core Apify platform tools for Strands Agents.
+
+Available Tools:
+---------------
+- apify_run_actor: Run any Apify Actor with custom input
+- apify_get_dataset_items: Fetch items from an Apify dataset with pagination
+- apify_run_actor_and_get_dataset: Run an Actor and fetch results in one step
+- apify_run_task: Run a saved Actor task with optional input overrides
+- apify_run_task_and_get_dataset: Run a task and fetch results in one step
+- apify_scrape_url: Scrape a single URL and return content as Markdown
+"""
+
+import json
+from typing import Any
+
+from strands import tool
+
+from .utils import (
+    DEFAULT_DATASET_ITEMS_LIMIT,
+    DEFAULT_SCRAPE_TIMEOUT_SECS,
+    DEFAULT_TIMEOUT_SECS,
+    ApifyToolClient,
+    CrawlerType,
+    _check_dependency,
+    _error_result,
+    _success_result,
+)
+
+
+@tool
+def apify_run_actor(
+    actor_id: str,
+    run_input: dict[str, Any] | None = None,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+    memory_mbytes: int | None = None,
+    build: str | None = None,
+) -> dict[str, Any]:
+    """Run any Apify Actor and return the run metadata as JSON.
+
+    An Actor is a serverless cloud app on the Apify platform - it takes JSON input,
+    runs the scraping or automation job, and writes results to a dataset. This tool
+    executes the Actor synchronously and returns run metadata only (run_id, status,
+    dataset_id, timestamps). Use apify_run_actor_and_get_dataset to also fetch the
+    output data in one call, or apify_scrape_url for quick single-URL extraction.
+
+    Common Actors:
+    - "apify/website-content-crawler" - scrape websites and extract content as Markdown
+    - "apify/web-scraper" - general-purpose web scraper with JS rendering
+    - "apify/google-search-scraper" - scrape Google search results
+
+    Args:
+        actor_id: Actor identifier in "username/actor-name" format,
+            e.g. "apify/website-content-crawler". Find Actors at https://apify.com/store.
+        run_input: JSON-serializable input for the Actor. Each Actor defines its own
+            input schema - check the Actor README on Apify Store for required fields.
+        timeout_secs: Maximum time in seconds to wait for the Actor run to finish. Defaults to 300.
+        memory_mbytes: Memory allocation in MB for the Actor run. Uses Actor default `memory` value if not set.
+        build: Actor build tag or number to run a specific version. Uses latest build if not set.
+
+    Returns:
+        Dict with status and content containing run metadata: run_id, status, dataset_id,
+        started_at, finished_at.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        result = client.run_actor(
+            actor_id=actor_id,
+            run_input=run_input,
+            timeout_secs=timeout_secs,
+            memory_mbytes=memory_mbytes,
+            build=build,
+        )
+        return _success_result(
+            text=json.dumps(result, indent=2, default=str),
+            panel_body=(
+                f"[green]Actor run completed[/green]\n"
+                f"Actor: {actor_id}\n"
+                f"Run ID: {result['run_id']}\n"
+                f"Status: {result['status']}\n"
+                f"Dataset ID: {result['dataset_id']}"
+            ),
+            panel_title="Apify: Run Actor",
+        )
+    except Exception as e:
+        return _error_result(e, "apify_run_actor")
+
+
+@tool
+def apify_get_dataset_items(
+    dataset_id: str,
+    limit: int = DEFAULT_DATASET_ITEMS_LIMIT,
+    offset: int = 0,
+) -> dict[str, Any]:
+    """Fetch items from an existing Apify dataset and return them as JSON.
+
+    Every Actor run writes its output to a dataset - a structured, append-only store
+    for tabular data. Use the dataset_id from the run metadata returned by apify_run_actor
+    or apify_run_task. Use offset for pagination through large datasets.
+
+    Args:
+        dataset_id: The Apify dataset ID to fetch items from.
+        limit: Maximum number of items to return. Defaults to 100.
+        offset: Number of items to skip for pagination. Defaults to 0.
+
+    Returns:
+        Dict with status and content containing an array of dataset items.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        items = client.get_dataset_items(dataset_id=dataset_id, limit=limit, offset=offset)
+        return _success_result(
+            text=json.dumps(items, indent=2, default=str),
+            panel_body=(
+                f"[green]Dataset items retrieved[/green]\nDataset ID: {dataset_id}\nItems returned: {len(items)}"
+            ),
+            panel_title="Apify: Dataset Items",
+        )
+    except Exception as e:
+        return _error_result(e, "apify_get_dataset_items")
+
+
+@tool
+def apify_run_actor_and_get_dataset(
+    actor_id: str,
+    run_input: dict[str, Any] | None = None,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+    memory_mbytes: int | None = None,
+    build: str | None = None,
+    dataset_items_limit: int = DEFAULT_DATASET_ITEMS_LIMIT,
+    dataset_items_offset: int = 0,
+) -> dict[str, Any]:
+    """Run an Apify Actor and fetch its dataset results in one step.
+
+    Convenience tool that combines running an Actor and fetching its default dataset
+    items into a single call. Use this when you want both the run metadata and the
+    result data without making two separate tool calls.
+
+    Args:
+        actor_id: Actor identifier in "username/actor-name" format,
+            e.g. "apify/website-content-crawler". Find Actors at https://apify.com/store.
+        run_input: JSON-serializable input for the Actor. Each Actor defines its own
+            input schema - check the Actor README on Apify Store for required fields.
+        timeout_secs: Maximum time in seconds to wait for the Actor run to finish. Defaults to 300.
+        memory_mbytes: Memory allocation in MB for the Actor run. Uses Actor default `memory` value if not set.
+        build: Actor build tag or number to run a specific version. Uses latest build if not set.
+        dataset_items_limit: Maximum number of dataset items to return. Defaults to 100.
+        dataset_items_offset: Number of dataset items to skip for pagination. Defaults to 0.
+
+    Returns:
+        Dict with status and content containing run metadata (run_id, status, dataset_id,
+        started_at, finished_at) plus an "items" array containing the dataset results.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        result = client.run_actor_and_get_dataset(
+            actor_id=actor_id,
+            run_input=run_input,
+            timeout_secs=timeout_secs,
+            memory_mbytes=memory_mbytes,
+            build=build,
+            dataset_items_limit=dataset_items_limit,
+            dataset_items_offset=dataset_items_offset,
+        )
+        return _success_result(
+            text=json.dumps(result, indent=2, default=str),
+            panel_body=(
+                f"[green]Actor run completed with dataset[/green]\n"
+                f"Actor: {actor_id}\n"
+                f"Run ID: {result['run_id']}\n"
+                f"Status: {result['status']}\n"
+                f"Dataset ID: {result['dataset_id']}\n"
+                f"Items returned: {len(result['items'])}"
+            ),
+            panel_title="Apify: Run Actor + Dataset",
+        )
+    except Exception as e:
+        return _error_result(e, "apify_run_actor_and_get_dataset")
+
+
+@tool
+def apify_run_task(
+    task_id: str,
+    task_input: dict[str, Any] | None = None,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+    memory_mbytes: int | None = None,
+) -> dict[str, Any]:
+    """Run a saved Apify task and return the run metadata as JSON.
+
+    Tasks are saved Actor configurations with preset inputs, managed in Apify Console.
+    Use this when a task has already been configured, so you don't need to specify
+    the full Actor input every time. Use apify_run_task_and_get_dataset to also fetch
+    the output data in one call.
+
+    Args:
+        task_id: Task identifier in "username/task-name" format or a task ID string.
+        task_input: Optional JSON-serializable input to override the task's default input fields.
+        timeout_secs: Maximum time in seconds to wait for the task run to finish. Defaults to 300.
+        memory_mbytes: Memory allocation in MB for the task run. Uses task default `memory` value if not set.
+
+    Returns:
+        Dict with status and content containing run metadata: run_id, status, dataset_id,
+        started_at, finished_at.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        result = client.run_task(
+            task_id=task_id,
+            task_input=task_input,
+            timeout_secs=timeout_secs,
+            memory_mbytes=memory_mbytes,
+        )
+        return _success_result(
+            text=json.dumps(result, indent=2, default=str),
+            panel_body=(
+                f"[green]Task run completed[/green]\n"
+                f"Task: {task_id}\n"
+                f"Run ID: {result['run_id']}\n"
+                f"Status: {result['status']}\n"
+                f"Dataset ID: {result['dataset_id']}"
+            ),
+            panel_title="Apify: Run Task",
+        )
+    except Exception as e:
+        return _error_result(e, "apify_run_task")
+
+
+@tool
+def apify_run_task_and_get_dataset(
+    task_id: str,
+    task_input: dict[str, Any] | None = None,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+    memory_mbytes: int | None = None,
+    dataset_items_limit: int = DEFAULT_DATASET_ITEMS_LIMIT,
+    dataset_items_offset: int = 0,
+) -> dict[str, Any]:
+    """Run a saved Apify task and fetch its dataset results in one step.
+
+    Convenience tool that combines running a task and fetching its default dataset
+    items into a single call. Use this when you want both the run metadata and the
+    result data without making two separate tool calls.
+
+    Args:
+        task_id: Task identifier in "username/task-name" format or a task ID string.
+        task_input: Optional JSON-serializable input to override the task's default input fields.
+        timeout_secs: Maximum time in seconds to wait for the task run to finish. Defaults to 300.
+        memory_mbytes: Memory allocation in MB for the task run. Uses task default `memory` value if not set.
+        dataset_items_limit: Maximum number of dataset items to return. Defaults to 100.
+        dataset_items_offset: Number of dataset items to skip for pagination. Defaults to 0.
+
+    Returns:
+        Dict with status and content containing run metadata (run_id, status, dataset_id,
+        started_at, finished_at) plus an "items" array containing the dataset results.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        result = client.run_task_and_get_dataset(
+            task_id=task_id,
+            task_input=task_input,
+            timeout_secs=timeout_secs,
+            memory_mbytes=memory_mbytes,
+            dataset_items_limit=dataset_items_limit,
+            dataset_items_offset=dataset_items_offset,
+        )
+        return _success_result(
+            text=json.dumps(result, indent=2, default=str),
+            panel_body=(
+                f"[green]Task run completed with dataset[/green]\n"
+                f"Task: {task_id}\n"
+                f"Run ID: {result['run_id']}\n"
+                f"Status: {result['status']}\n"
+                f"Dataset ID: {result['dataset_id']}\n"
+                f"Items returned: {len(result['items'])}"
+            ),
+            panel_title="Apify: Run Task + Dataset",
+        )
+    except Exception as e:
+        return _error_result(e, "apify_run_task_and_get_dataset")
+
+
+@tool
+def apify_scrape_url(
+    url: str,
+    timeout_secs: int = DEFAULT_SCRAPE_TIMEOUT_SECS,
+    crawler_type: CrawlerType = "cheerio",
+) -> dict[str, Any]:
+    """Scrape a single URL and return its content as Markdown.
+
+    Uses the Website Content Crawler Actor under the hood, pre-configured for
+    fast single-page scraping. This is the simplest way to extract readable content
+    from any web page - no Actor input schema needed. For multi-page crawls, use
+    apify_run_actor_and_get_dataset with "apify/website-content-crawler" directly.
+
+    Args:
+        url: The URL to scrape, e.g. "https://example.com".
+        timeout_secs: Maximum time in seconds to wait for scraping to finish. Defaults to 120.
+        crawler_type: Crawler engine to use. One of:
+            - "cheerio" (default): Fastest, no JavaScript rendering. Best for static HTML.
+            - "playwright:adaptive": Renders JS only when needed. Good general-purpose choice.
+            - "playwright:firefox": Full JS rendering, best at bypassing anti-bot protection but slowest.
+
+    Returns:
+        Dict with status and content containing the Markdown content of the scraped page.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        content = client.scrape_url(url=url, timeout_secs=timeout_secs, crawler_type=crawler_type)
+        return _success_result(
+            text=content,
+            panel_body=(
+                f"[green]URL scraped successfully[/green]\nURL: {url}\nContent length: {len(content)} characters"
+            ),
+            panel_title="Apify: Scrape URL",
+        )
+    except Exception as e:
+        return _error_result(e, "apify_scrape_url")
+
+
+APIFY_CORE_TOOLS = [
+    apify_run_actor,
+    apify_get_dataset_items,
+    apify_run_actor_and_get_dataset,
+    apify_run_task,
+    apify_run_task_and_get_dataset,
+    apify_scrape_url,
+]

strands_apify/search_crawling.py

@@ -0,0 +1,302 @@
+"""Apify search and web crawling tools for Strands Agents.
+
+Available Tools:
+---------------
+- apify_google_search_scraper: Search Google and return structured results
+- apify_google_places_scraper: Search Google Maps for places and businesses
+- apify_youtube_scraper: Scrape YouTube videos, channels, or search results
+- apify_website_content_crawler: Multi-page website crawl with markdown extraction
+- apify_ecommerce_scraper: Scrape product data from e-commerce sites
+"""
+
+import json
+from typing import Any
+
+from strands import tool
+
+from .utils import (
+    DEFAULT_TIMEOUT_SECS,
+    WEBSITE_CONTENT_CRAWLER,
+    ApifyToolClient,
+    _check_dependency,
+    _error_result,
+    _success_result,
+    _validate_url,
+    _validate_urls,
+)
+
+GOOGLE_SEARCH_SCRAPER_ID = "apify/google-search-scraper"
+GOOGLE_PLACES_SCRAPER_ID = "compass/crawler-google-places"
+YOUTUBE_SCRAPER_ID = "streamers/youtube-scraper"
+ECOMMERCE_SCRAPER_ID = "apify/e-commerce-scraping-tool"
+DEFAULT_SEARCH_RESULTS_LIMIT = 20
+
+VALID_ECOMMERCE_URL_TYPES = ("product", "listing")
+
+
+def _search_crawl_result(
+    actor_name: str,
+    client: ApifyToolClient,
+    run_input: dict[str, Any],
+    actor_id: str,
+    timeout_secs: int,
+    results_limit: int,
+) -> dict[str, Any]:
+    """Run a search/crawling Actor and return formatted results."""
+    result = client.run_actor_and_get_dataset(
+        actor_id=actor_id,
+        run_input=run_input,
+        timeout_secs=timeout_secs,
+        dataset_items_limit=results_limit,
+    )
+    return _success_result(
+        text=json.dumps(result, indent=2, default=str),
+        panel_body=(
+            f"[green]{actor_name} completed[/green]\nRun ID: {result['run_id']}\nItems returned: {len(result['items'])}"
+        ),
+        panel_title=f"Apify: {actor_name}",
+    )
+
+
+@tool
+def apify_google_search_scraper(
+    search_query: str,
+    results_limit: int = 10,
+    country_code: str | None = None,
+    language_code: str | None = None,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+) -> dict[str, Any]:
+    """Search Google and return structured search results.
+
+    Uses the Google Search Scraper Actor to perform a Google search and return
+    organic results, ads, People Also Ask, and related queries in a structured format.
+
+    Args:
+        search_query: The search query string, e.g. "best AI frameworks 2025".
+            Supports advanced Google operators like "site:example.com" or "AI OR ML".
+        results_limit: Maximum number of results to return. Google returns ~10 results
+            per page, so requesting more triggers additional page scraping. Defaults to 10.
+        country_code: Two-letter country code for localized results, e.g. "us", "de".
+        language_code: Two-letter language code for the interface, e.g. "en", "de".
+        timeout_secs: Maximum time in seconds to wait for the run to finish. Defaults to 300.
+
+    Returns:
+        Dict with status and content containing structured Google search results including
+        organic results, ads, and People Also Ask data.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        max_pages = max(1, (results_limit + 9) // 10)
+        run_input: dict[str, Any] = {
+            "queries": search_query,
+            "maxPagesPerQuery": max_pages,
+        }
+        if country_code is not None:
+            run_input["countryCode"] = country_code
+        if language_code is not None:
+            run_input["languageCode"] = language_code
+        return _search_crawl_result(
+            actor_name="Google Search Scraper",
+            client=client,
+            run_input=run_input,
+            actor_id=GOOGLE_SEARCH_SCRAPER_ID,
+            timeout_secs=timeout_secs,
+            results_limit=results_limit,
+        )
+    except Exception as e:
+        return _error_result(e, "apify_google_search_scraper")
+
+
+@tool
+def apify_google_places_scraper(
+    search_query: str,
+    results_limit: int = DEFAULT_SEARCH_RESULTS_LIMIT,
+    language: str | None = None,
+    include_reviews: bool = False,
+    max_reviews: int = 5,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+) -> dict[str, Any]:
+    """Search Google Maps for businesses and places, optionally including reviews.
+
+    Uses the Google Maps Scraper Actor to find places matching a search query
+    and return structured data including name, address, rating, phone, and website.
+
+    Args:
+        search_query: Search query for Google Maps, e.g. "restaurants in Prague".
+        results_limit: Maximum number of places to return. Defaults to 20.
+        language: Language for results, e.g. "en", "de". Defaults to English.
+        include_reviews: Whether to include user reviews for each place. Defaults to False.
+        max_reviews: Maximum reviews per place when include_reviews is True. Defaults to 5.
+        timeout_secs: Maximum time in seconds to wait for the run to finish. Defaults to 300.
+
+    Returns:
+        Dict with status and content containing structured Google Maps place data.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        run_input: dict[str, Any] = {
+            "searchStringsArray": [search_query],
+            "maxCrawledPlacesPerSearch": results_limit,
+            "maxReviews": max_reviews if include_reviews else 0,
+        }
+        if language is not None:
+            run_input["language"] = language
+        return _search_crawl_result(
+            actor_name="Google Places Scraper",
+            client=client,
+            run_input=run_input,
+            actor_id=GOOGLE_PLACES_SCRAPER_ID,
+            timeout_secs=timeout_secs,
+            results_limit=results_limit,
+        )
+    except Exception as e:
+        return _error_result(e, "apify_google_places_scraper")
+
+
+@tool
+def apify_youtube_scraper(
+    search_query: str | None = None,
+    urls: list[str] | None = None,
+    results_limit: int = DEFAULT_SEARCH_RESULTS_LIMIT,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+) -> dict[str, Any]:
+    """Scrape YouTube videos, channels, or search results.
+
+    Uses the YouTube Scraper Actor to search YouTube or scrape specific video/channel
+    URLs. Provide either a search query, specific URLs, or both.
+
+    Args:
+        search_query: YouTube search query, e.g. "python tutorial".
+        urls: Specific YouTube video or channel URLs to scrape.
+        results_limit: Maximum number of results to return. Defaults to 20.
+        timeout_secs: Maximum time in seconds to wait for the run to finish. Defaults to 300.
+
+    Returns:
+        Dict with status and content containing structured YouTube video/channel data.
+    """
+    try:
+        _check_dependency()
+        if not search_query and not urls:
+            raise ValueError("At least one of 'search_query' or 'urls' must be provided.")
+        if urls is not None:
+            _validate_urls(urls, "urls")
+        client = ApifyToolClient()
+        run_input: dict[str, Any] = {
+            "maxResults": results_limit,
+        }
+        if search_query is not None:
+            run_input["searchQueries"] = [search_query]
+        if urls is not None:
+            run_input["startUrls"] = [{"url": u} for u in urls]
+        return _search_crawl_result(
+            actor_name="YouTube Scraper",
+            client=client,
+            run_input=run_input,
+            actor_id=YOUTUBE_SCRAPER_ID,
+            timeout_secs=timeout_secs,
+            results_limit=results_limit,
+        )
+    except Exception as e:
+        return _error_result(e, "apify_youtube_scraper")
+
+
+@tool
+def apify_website_content_crawler(
+    start_url: str,
+    max_pages: int = 10,
+    max_depth: int = 2,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+) -> dict[str, Any]:
+    """Crawl a website and extract content from multiple pages.
+
+    Uses the Website Content Crawler Actor to perform a multi-page crawl starting
+    from the given URL. Returns page content as markdown. This is the extended
+    multi-page version - distinct from apify_scrape_url which scrapes a single page.
+
+    Args:
+        start_url: The starting URL to crawl, e.g. "https://docs.example.com".
+        max_pages: Maximum number of pages to crawl. Defaults to 10.
+        max_depth: Maximum crawl depth from the start URL. Defaults to 2.
+        timeout_secs: Maximum time in seconds to wait for the run to finish. Defaults to 300.
+
+    Returns:
+        Dict with status and content containing crawled page data with markdown content.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        _validate_url(start_url)
+        run_input: dict[str, Any] = {
+            "startUrls": [{"url": start_url}],
+            "maxCrawlPages": max_pages,
+            "maxCrawlDepth": max_depth,
+            "proxyConfiguration": {"useApifyProxy": True},
+        }
+        return _search_crawl_result(
+            actor_name="Website Content Crawler",
+            client=client,
+            run_input=run_input,
+            actor_id=WEBSITE_CONTENT_CRAWLER,
+            timeout_secs=timeout_secs,
+            results_limit=max_pages,
+        )
+    except Exception as e:
+        return _error_result(e, "apify_website_content_crawler")
+
+
+@tool
+def apify_ecommerce_scraper(
+    url: str,
+    url_type: str = "product",
+    results_limit: int = DEFAULT_SEARCH_RESULTS_LIMIT,
+    timeout_secs: int = DEFAULT_TIMEOUT_SECS,
+) -> dict[str, Any]:
+    """Scrape product data from e-commerce websites.
+
+    Uses the E-commerce Scraping Tool Actor to extract structured product data
+    (title, price, description, images, etc.) from supported e-commerce platforms
+    including Amazon, eBay, Walmart, and others. The Actor auto-detects the site.
+
+    Args:
+        url: The URL to scrape.
+        url_type: Type of URL being scraped. Use "product" (default) for a direct product
+            detail page, or "listing" for a category page or search results page containing
+            multiple products.
+        results_limit: Maximum number of products to return. Defaults to 20.
+        timeout_secs: Maximum time in seconds to wait for the run to finish. Defaults to 300.
+
+    Returns:
+        Dict with status and content containing structured product data.
+    """
+    try:
+        _check_dependency()
+        client = ApifyToolClient()
+        _validate_url(url)
+        if url_type not in VALID_ECOMMERCE_URL_TYPES:
+            raise ValueError(f"Invalid url_type '{url_type}'. Must be one of: {', '.join(VALID_ECOMMERCE_URL_TYPES)}.")
+        url_field = "listingUrls" if url_type == "listing" else "detailsUrls"
+        run_input: dict[str, Any] = {
+            url_field: [{"url": url}],
+            "maxProductResults": results_limit,
+        }
+        return _search_crawl_result(
+            actor_name="E-commerce Scraper",
+            client=client,
+            run_input=run_input,
+            actor_id=ECOMMERCE_SCRAPER_ID,
+            timeout_secs=timeout_secs,
+            results_limit=results_limit,
+        )
+    except Exception as e:
+        return _error_result(e, "apify_ecommerce_scraper")
+
+
+APIFY_SEARCH_TOOLS = [
+    apify_google_search_scraper,
+    apify_google_places_scraper,
+    apify_youtube_scraper,
+    apify_website_content_crawler,
+    apify_ecommerce_scraper,
+]