Skip to main content

Overview

Tool Name

Purpose

The web_access_tools group lets you discover and retrieve web content on demand. Run targeted Google searches, scrape specific pages to extract titles, metadata, text, links, tables, and more, and call authenticated APIs or downloads when your workflow needs protected content. Use generic auth only for arbitrary APIs. For connection-managed provider APIs such as GitLab /api/v4/..., Jira /rest/api/... and /rest/servicedeskapi/..., or Azure Data Factory management APIs, use connection_api_action or provider-specific tooling instead of passing PATs, bearer headers, or service-principal credentials through generic web auth.
Use Browser Tools when a workflow must interact with a live UI by navigating, clicking, typing, or inspecting current page state. Use web_access_tools for page reads, REST APIs, and file downloads.
For get_web_content, browser-backed actions (web_page, batch_pages, orchestrate, start_session, and session_actions) return an unavailable error when Chromium is not included in a Databricks App deployment. Use static_html for pages that do not need JavaScript, or api_data for an API; these actions do not start a browser.

Key Features & Functions

Web Search (Serper or Tavily)

Query the open web with two providers: serper (Google SERP via Serper) for navigational and multi-type searches, or tavily (LLM/agent-optimized search) for clean snippets and optional inline page-text extraction.

Precise Page Scraping

Fetch a URL and extract structured content such as headings, paragraphs, lists, links, and images.

Structured Data Capture

Parse tables and other page elements for downstream analytics or indexing.

Authenticated API Access

Prompt for credentials securely for arbitrary APIs, call protected endpoints, reuse saved Connections for connection-managed provider APIs, and download files with structured auth settings and clearer diagnostics.

Result Ranking & Filtering

Receive ranked results with snippets and metadata to keep only what matters.

Workflow Integration

Feed outputs into indexing, storage, and collaboration tools for end-to-end research pipelines.
Start broad, then refine. Use a general search to map the space, follow up with focused queries and selective scraping of the best sources.

Input Parameters for Each Function

_scrape_url

On Genesis AI (Genesis Desktop or a hosted Try Me instance using its owner’s credit), _scrape_url can fetch a page without a Serper key. Genesis fetches the public page directly at no charge; it returns static content and does not render JavaScript. A configured Serper key continues to take precedence. Parameters

search_web

Use search_web for open-web research. Genesis supports two providers:
  • serper — Google SERP via Serper (serper.dev). Best for navigational queries and the full range of search_type values.
  • tavily — LLM/agent-optimized search (tavily.com). Returns pre-processed snippets and can return extracted page text inline (include_raw_content), collapsing search → fetch → parse into one call.
On Genesis AI (Genesis Desktop or a hosted Try Me instance using its owner’s credit), search_web also works without a search key when the Genesis-issued LiteLLM proxy key is active. With neither a personal Serper nor Tavily key configured, provider='auto' (or 'serper') uses Genesis AI’s built-in Google search, billed to the applicable Genesis AI credit. A configured key for the selected provider takes precedence; provider='tavily' requires a Tavily key. Genesis AI search supports general web search only: other search_type values fall back to general search, and Tavily-only parameters are ignored; both cases are reported in meta.notices[]. Genesis AI searches cap max_results at 20. Setup actions Keys can also be configured as Connections (google_search and tavily types in Config → Connections), or via the SERPER_API_KEY / TAVILY_API_KEY environment variables. When you paste a key through set_serper_key or set_tavily_key, Genesis stores it as your personal connection and sets it as your user default. For org-wide setup, create a shared connection in Config → Connections and assign it as a role default. Search parameters Tavily-only parameters (ignored for serper, with a meta.notices[] entry) Example
Response shape Returns { success, data?: { engine, provider, query, organic: [{ title, link, snippet, raw_content? }], meta: { notices[] } }, raw?, error? }. provider can be serper, tavily, or genesis_ai; Genesis AI results use engine: "google". organic[].raw_content is present only for Tavily results that returned extracted page text. See Cost accounting for web-request metering.

get_web_content with action="ask_user_for_secret"

Parameters
status="not_tried" returns an existing secret silently when one is already stored. status="failed" always opens an in-chat update card so the user can replace a credential that did not work. When Genesis does need input, it anchors the credential card to the related assistant reply instead of opening a blocking modal. This action returns only the secret_name; the credential value stays in the Genesis secret vault. If the user does not respond within 600 seconds, the request times out.
If an arbitrary API call needs a credential, call get_web_content(action="ask_user_for_secret") immediately. Do not ask users to paste API keys, passwords, or tokens into chat first. For configured Connections such as GitLab /api/v4/... or Jira /rest/api/..., do not ask for PATs or bearer tokens here. Use connection_api_action or provider-specific GitLab or Jira tooling, and ask the user to configure or reauthorize the Connection if needed.
Example

get_web_content with action="api_data"

Auth-related parameters On Databricks Apps, api_data and api_data_batch downloads and static_html files saved with save_to_file follow the durable chat uploads behavior.

auth.type="api_key" header and query options

If an API expects the raw token directly in the Authorization header, use auth.type="api_key" with location="header" and header_name="Authorization" and leave prefix empty. Use prefix="Bearer" only when the endpoint explicitly requires Authorization: Bearer <token>.
The usual sequence is: first call ask_user_for_secret, then pass the returned secret_name in the relevant auth field on the next api_data request.
GitLab REST calls under /api/v4 still require connection-backed tooling and are blocked before secrets or auth are resolved; GitLab GraphQL queries can be read here. For GitHub, Jira, Salesforce, HubSpot, Linear, ServiceNow, and Databricks, reads remain available, but a request that changes provider data is refused before it is sent with error_code="RAW_WRITE_REQUIRES_GOVERNED_TOOL" and a governed_tool field naming the replacement. GraphQL queries and Databricks SQL reads sent as POST are treated as reads; a body resolved from secrets is treated as a write.
The governed tool does not always submit changes for Action Review. GitLab, GitHub, Jira, Linear, ServiceNow, and Databricks writes use their named governed tools; Salesforce merges and Lead, Contact, or Account deletes, and HubSpot merges, go through Action Review. Salesforce creates, updates, upserts, and other deletes, plus HubSpot creates, updates, and upserts, use the connector under the saved Connection’s permissions. HubSpot deletes and archives, and Salesforce anonymous Apex, are not available through Genesis.
The web tool does not follow redirects for non-GET requests. A 303 response is reported as a successful delivered write; other write redirects return WRITE_REDIRECT_NOT_FOLLOWED with write_delivered, redirect_followed, and redirect_location. The request was already delivered to the original server, so check whether it applied before retrying.
When a blocked provider URL is supplied, the response also includes a connection_finder result when discovery can run. That result contains ranked visible connections. The server returns auto_select only for one warning-free exact match and user_must_pick otherwise, so an agent can use an existing connection instead of falling back to generic web search or asking for provider credentials. Example

connection_api_action

Use connection_api_action for long-tail provider REST API calls that must run through a saved Connection. It supports gitlab, jira, and azure_data_factory. For GitLab and Jira it only reads (GET): a POST, PUT, PATCH, or DELETE is refused with error_code RAW_WRITE_REQUIRES_GOVERNED_TOOL and nothing is sent, because GitLab changes go through git_action and Jira changes through jira_connector, which run them under Action Review. For Azure Data Factory, use it for management-plane operations such as listing or updating pipelines, enumerating triggers, datasets, or linked services, and querying pipeline runs. Parameters
connection_api_action resolves credentials from the saved Connection and rejects caller-supplied PATs, bearer tokens, auth configs, or provider auth headers. For Azure Data Factory, the saved service principal is exchanged for an Azure Resource Manager bearer token and every request is scoped to the Connection’s subscription; api-version defaults to 2018-06-01 when omitted. If the Connection is missing, ask the user to configure it. If the Connection needs OAuth renewal, Genesis starts the reauthorization flow.
Successful responses include success, provider (gitlab, jira, or azure_data_factory), connection_name, method, path, and status_code, plus optional content. When save_to_file is used, Genesis also returns saved, file_path, path, and timestamp; the saved path can differ from the requested path. See durable chat uploads for Databricks behavior and durability_warning. Azure Data Factory POST, PUT, and PATCH calls also include mutation_guidance.
When return_content is true, JSON bodies are parsed and returned in full — including GitLab repository files metadata responses that carry an entire file as base64 inside JSON. Non-JSON bodies (for example GitLab /raw file downloads) are returned in full when they are 4000 characters or fewer. Larger non-JSON bodies are never silently truncated: content is only the first 4000 characters (a preview), and Genesis also returns content_truncated (true), content_total_chars, content_preview_chars (4000), and a note explaining that the preview must not be edited or committed. Unless you passed save_to_file, Genesis auto-saves the complete body under bot_git/repos/uploads/<thread_id>/connection_api/<timestamp>_<filename> and returns saved, file_path, path, uploads_relative_path, and timestamp; on save failure it returns full_content_save_error instead. When uploads_relative_path is present, read the full plaintext file back with the file tool — no decoding — using file(action="read", repo_id="uploads", file_path="<uploads_relative_path>") and edit or commit only from that full content. The note field includes this recovery hint; do not reconstruct the file from the inline preview or decode base64 from a GitLab files metadata response.
Examples

Use Cases

  1. Market and industry research Identify trends, competitors, and benchmarks from trusted sources.
  2. Real-time news monitoring Track breaking updates that affect active missions and roadmaps.
  3. Technical discovery Locate docs, guides, and best practices for engineering solutions.
  4. Scholarly evidence gathering Pull academic articles or patents to support recommendations.
  5. Vendor and product validation Collect specifications and pricing from official sites.
  6. Regulatory checks Retrieve policies and compliance notes from government domains.
  7. Visual asset sourcing Find images or videos for briefings and presentations.
  8. Connection-backed provider API calls Call long-tail GitLab or Jira/JSM REST endpoints through a saved Connection without exposing PATs or bearer tokens in chat history.

Workflow/How It Works

  1. Search with search_web using carefully scoped keywords, a provider when you need to force Serper or Tavily, and a search_type when needed.
  2. Select sources by reviewing titles, snippets, and domains for credibility.
  3. Scrape chosen pages with _scrape_url to extract structured content.
  4. Store or index outputs for retrieval and cross-referencing in later steps.
  5. Cite and share the most relevant excerpts in reports, docs, or Slack updates.
Respect robots.txt, site terms, and rate limits. Avoid scraping authenticated or prohibited areas and throttle requests to prevent blocking.

Integration Relevance

  • document_index_tools to index scraped pages for semantic search and Q&A.
  • file_manager_tools to persist captured pages and datasets.
  • project_manager_tools to track research tasks and sources.
  • slack_tools to share links and summaries with teams.
  • artifact_manager_tools to preserve snapshots of key findings.

Configuration Details

  • Provide fully qualified URLs with https when possible.
  • Match search_type to the content you want to reduce noise. Use Tavily + include_raw_content when you need page text back in one call; use serper for image, maps, scholar, or patents result types.
  • Configure API keys via Connections (google_search, tavily), search_web(action='set_serper_key'|'set_tavily_key') (creates a personal connection and user default), or SERPER_API_KEY / TAVILY_API_KEY environment variables. Use shared Connections with role defaults for org-wide keys.
  • Set network timeouts conservatively for slower sites.
  • Normalize extracted tables before analysis to handle irregular markup.
Some rich pages load data via client-side JavaScript. If a target renders content dynamically, scraping may return partial results.

Limitations or Notes

  1. Access can be blocked by anti-bot protections or require sign-in.
  2. Dynamic or interactive elements might not render in basic HTML responses.
  3. Search relevance depends on the query and the underlying index.
  4. International or non-English pages may need language-aware processing.
  5. Sponsored results may appear and should be filtered for neutrality.
  6. Copyright and usage rights apply to collected content. Assess before reuse.

Output

  • Scraping Results Page title, meta description, structured metadata, main content, links, images, table data, and basic load metrics.
  • Search Results Ranked items with titles, snippets, URLs, source details, and related-query hints.
  • Saved API and Download Results File metadata including status_code, content_type, file_size_bytes, file_size_mb, timestamp, preview text for JSON/text/CSV/XML where available, and read_instructions when the file is saved into a Git-backed repo.
  • Errors and Diagnostics Clear messages for network failures, blocked access, invalid URLs, or empty results. Saved API and download failures can also include a masked response_body, successful raw-token retries can return an auth_note explaining that the request succeeded only after removing the Bearer prefix, and blocked connection-managed provider calls return error_code="CONNECTION_BACKED_API_REQUIRED" with the recommended next tool and actions.