Grow Therapy provider search

Search Grow Therapy for therapists by location, insurance, and specialty — with cached reruns.

This tutorial builds a provider search tool for Grow Therapy — a therapy marketplace that handles insurance credentialing for providers. We combine structured output with saved scripts to build a fast, repeatable search pipeline.

What you’ll build

A script that:

1. Searches Grow Therapy’s provider directory with filters (location, insurance, specialty)
2. Extracts therapist profiles with ratings and availability
3. Caches a successful search flow for reruns with different locations and specialties

---

Setup

Python

import asyncio
import json
from pydantic import BaseModel
from browser_use_sdk.v3 import AsyncBrowserUse

client = AsyncBrowserUse()

1. Define the output schema

Python

class Provider(BaseModel):
    name: str
    title: str
    specialties: list[str]
    insurance_plans: list[str]
    rating: float | None = None
    next_available: str | None = None

class ProviderSearch(BaseModel):
    providers: list[Provider]
    total_found: int | None = None
    location: str
    specialty: str

2. Create a workspace

Python

workspace = await client.workspaces.create(name="grow-therapy-search")

3. Search for providers

This tutorial uses API V3 automatic script caching. Mark changing values with @{{value}}; plain {{value}} does not activate caching. Keep the rest of the task text and the workspace unchanged so later requests can find the same cached script. The first successful generation uses the agent and incurs normal usage charges.

Python

result = await client.run(
    "Go to growtherapy.com and search for therapists in @{{New York}} "
    "who specialize in @{{anxiety}} and accept insurance. "
    "Return the first 5 provider profiles as JSON.",
    workspace_id=str(workspace.id),
    output_schema=ProviderSearch,
)

for p in result.output.providers:
    print(f"{p.name} ({p.title})")
    print(f"  Specialties: {', '.join(p.specialties)}")
    print(f"  Rating: {p.rating}")
    print(f"  Next available: {p.next_available}")
    print()

4. Sweep across locations and specialties

After a successful first run caches the search flow, change only the marked values. A successful cached script execution avoids agent LLM inference, but browser and network usage still apply. Cache misses, validation, and automatic repair can invoke the agent and incur LLM charges; a rerun is not a guarantee of zero LLM cost.

Python

locations = ["Los Angeles", "Chicago", "Houston", "Miami"]
specialties = ["depression", "trauma", "ADHD"]

for location in locations:
    for specialty in specialties:
        result = await client.run(
            f"Go to growtherapy.com and search for therapists in @{{{{{location}}}}} "
            f"who specialize in @{{{{{specialty}}}}} and accept insurance. "
            f"Return the first 5 provider profiles as JSON.",
            workspace_id=str(workspace.id),
            output_schema=ProviderSearch,
        )
        count = len(result.output.providers)
        print(f"{location} / {specialty}: {count} providers found")

---

Summary

Step	What happens	Cost
First search or cache miss	Agent creates and validates the cached flow	Normal agent, browser, and network charges
Successful cached execution	Script reruns with new parameters	No agent LLM inference for script execution; browser and network charges apply
Validation or repair	Agent validates or repairs a flow that needs attention	LLM usage plus browser and network charges

Therapy platforms have dynamic UIs that can change frequently. V3 can automatically repair a cached flow when it fails. For new V4 integrations, use saved scripts; the V3 @{{value}} convention is specific to this tutorial’s API version.

Next steps

• Structured output — Learn more about extracting typed data with Pydantic and Zod schemas.
• Human in the loop — Let a human review or interact with the browser mid-task, useful for auth flows or approving results before continuing.
• Scripts — Save, reuse, and repair browser workflows.