Google Search and Google Shopping tools for LangChain

Step by step

1. 01Define the tools

   The @tool decorator from langchain_core.tools turns a typed, documented function into a tool. parse_docstring=True copies the Args section into the parameter descriptions the model sees.

   Each tool makes one live request and returns only the fields a model needs: the top 5 organic results, or the top 10 products. Raw responses also include ads, People Also Ask, AI Overview text and more, which you can add if your agent uses them.

   """LangChain tools for Google Search and Google Shopping via CrawlerData.
   pip install "langchain-core==1.6.10" "requests==2.34.2"
   """
   import os
   
   import requests
   from langchain_core.tools import tool
   
   API_URL = "https://api.crawlerdata.com/v1/jobs"
   HEADERS = {"Authorization": f"Bearer {os.environ['CRAWLERDATA_API_KEY']}"}
   
   
   def _live(endpoint: str, params: dict) -> dict:
       resp = requests.post(API_URL, headers=HEADERS, timeout=200,
                            json={"endpoint": endpoint, "params": params, "queue": "live"})
       resp.raise_for_status()
       data = resp.json()
       if data["job"]["status"] != "completed":
           raise RuntimeError(data["job"]["error"])
       return data["result"]
   
   
   @tool(parse_docstring=True)
   def google_search(query: str, country: str = "us") -> list[dict]:
       """Search Google and return the top organic results (title, url, snippet).
       Use it for current facts, news or anything you are not sure about.
   
       Args:
           query: The search query, as you would type it into Google.
           country: 2-letter country code such as us, gb or de.
       """
       result = _live("google-search", {"query": query, "country": country})
       return [{"title": r["title"], "url": r["link"], "snippet": r.get("snippet")}
               for r in result["organic_results"][:5]]
   
   
   @tool(parse_docstring=True)
   def google_shopping_search(query: str, country: str = "us") -> list[dict]:
       """Search Google Shopping and return products with price, merchant and product_id.
   
       Args:
           query: Product search, e.g. "sony wh-1000xm5".
           country: 2-letter country code such as us, gb or de.
       """
       result = _live("google-shopping-search", {"query": query, "country": country})
       return [{"title": p["title"], "price": p["price"]["raw"] if p.get("price") else None,
                "merchant": p.get("merchant"), "product_id": p["product_id"]}
               for p in result["shopping_results"][:10]]

2. 02Call them and inspect the schema

   Tools can be invoked directly, which is the quickest test. convert_to_openai_tool shows the JSON schema a model receives, with the docstring as the description.

   from langchain_core.utils.function_calling import convert_to_openai_tool
   
   from crawlerdata_tools import google_search, google_shopping_search
   
   # Call a tool directly, the way an agent would.
   print(google_search.invoke({"query": "langchain tool decorator"})[0])
   print(google_shopping_search.invoke({"query": "sony wh-1000xm5", "country": "us"})[:2])
   
   # The JSON schema the model sees (OpenAI function-calling format).
   print(convert_to_openai_tool(google_search))

3. 03Give them to your agent

   Pass tools=[google_search, google_shopping_search] to your agent, for example langchain.agents.create_agent(model, tools=[...]), or bind them to a chat model with model.bind_tools([...]). The tools work the same with any tool-calling model.

   A live search usually returns in a few seconds. Let tool calls run for up to about 200 seconds in your agent runtime, matching the client timeout.

4. 04Optional: LlamaIndex

   The function behind each LangChain tool is available as .func, so LlamaIndex can wrap it with FunctionTool.from_defaults. We tested this with llama-index-core 0.14.25.

   # pip install "llama-index-core==0.14.25"
   from llama_index.core.tools import FunctionTool
   
   from crawlerdata_tools import google_search
   
   search_tool = FunctionTool.from_defaults(
       fn=google_search.func,  # the plain Python function behind the LangChain tool
       name="google_search",
       description="Search Google and return the top results with title, url and snippet.",
   )

If something goes wrong

401 INVALID_API_KEY

The key is missing, mistyped or revoked. Send it as "Authorization: Bearer YOUR_API_KEY" (with the word Bearer and one space) and check the key is active under API Access in the dashboard.

KeyError: CRAWLERDATA_API_KEY

The module reads the key when it is imported. Export the variable before starting Python, or load your .env file first.

402 INSUFFICIENT_CREDITS

Your balance is too low for the request. Buy a credit pack in the dashboard. Requests that fail for other reasons are not charged, so a 402 never costs credits.

429 RATE_LIMITED

Each API key allows 100 requests per minute and 20 per second. Wait until the time in the X-RateLimit-Reset header (a Unix timestamp) and retry, or spread requests out.

Timeouts on live requests

A live request returns when the result is ready. Search requests usually take a few seconds; a Google Shopping sellers request collects every seller for the product, so allow more time. Set the client timeout to about 200 seconds, or use the fast queue and poll the job.

RuntimeError from the tool

The job failed, and the message is job.error. It cost 0 credits. Many agent frameworks pass tool errors back to the model, which can retry with a different query.

Request and response schemas: OpenAPI 3.1 document. Still stuck? Email contact@crawlerdata.com.

APIs you can call

Solutions built on it

Other integrations