How to Fetch Web Pages with TinyFish in a Jinba Workflow

Summary

• TinyFish provides a managed web-fetching tool that renders JavaScript-heavy pages and returns clean structured output in Markdown, HTML, or JSON, with SSRF protections.
• The workflow can fetch competitor pages, aggregate content, or monitor live sources, then route extracted data to 100+ integrations such as HubSpot, Gmail, Slack, and Salesforce.
• Centralised audit logging records who triggered each fetch, what TinyFish accessed, and every downstream action, supporting PCI-DSS and ISO compliance.
• To get started, describe the process in Jinba Flow, add and test the TinyFish step, publish the workflow, and confirm the audit trail before scaling.

Manual web data collection is slow, brittle, and difficult to govern. Teams that pull content from competitor pages, industry blogs, or live data sources face the same recurring constraints: raw HTML loaded with CSS, ads, and navigation clutter; JavaScript-rendered pages that basic scrapers miss entirely; and no standardised output format for downstream processing. Selecting a dedicated scraping service adds further friction, because the right choice between Playwright-based tools, proxy networks, and extraction layers depends on workload characteristics that are not always clear at the outset.

Jinba removes that decision point. As an enterprise AI workflow orchestration platform, Jinba enables organisations to build, run, and deploy reusable workflows, with or without code, and connect them to over 100 integrations. The TinyFish integration brings a purpose-built AI web agent into those workflows and handles rendering, extraction, and structured output within a single tool step.

This guide covers how to configure a web-fetching workflow using TinyFish inside Jinba Flow, route the output to downstream systems, and meet the audit requirements that production deployments demand.

The three Jinba components involved

Jinba organises its platform into three products, each with a distinct role.

Jinba Flow is the workflow design environment. Operators describe a process in natural language or build it visually using a flowchart editor. Finished workflows publish as APIs or batch processes.

Jinba App is the execution interface for end users. It exposes published workflows through a chat interface or an auto-generated input form, so non-technical users can trigger production-grade processes without accessing the underlying flow.

Jinba Toolbox manages the AI tools that workflows call. It handles registration, versioning, and sandboxed execution. TinyFish runs here, isolated from the rest of the infrastructure.

The distinction between layers matters before configuring the TinyFish integration. Each step in a Jinba flow is modular: the tool executes independently of the orchestration logic around it.

What TinyFish does inside a workflow

TinyFish is an AI web agent built for fetching and extracting content from live web pages. Its Fetch API operates as a dual-layer service: a rendering layer uses a Chromium pool to fully execute JavaScript before the page is read, and an extraction layer then processes the rendered output into structured data including title, author, and body content.

The result is available in Markdown, HTML, or JSON, depending on what the downstream step expects.

A direct API call to the TinyFish Fetch API looks like this:

curl -X POST https://api.fetch.tinyfish.ai \
-H "X-API-Key: $TINYFISH_API_KEY" \
-H "Content-Type: application/json" \
-d '{ "urls": ["https://example.com"] }'

Inside a Jinba workflow, this call is abstracted into a tool step. Organisations configure the URL or search query as an input parameter, and the structured response flows directly into the next step. The API also includes SSRF protections that block fetches to internal or risky URLs, which matters for any deployment touching production infrastructure.

The practical gap this fills is significant. Pages that return blank content to a basic HTTP request because they depend on client-side rendering are fetched correctly. Output arrives clean and without the navigation, ads, and stylesheet noise that makes raw HTML difficult to process downstream.

Building the workflow: step by step

The steps below follow the standard path from a blank Jinba Flow to a running, production-ready web-fetching workflow.

Step 1: Define the process in Jinba Flow

Open Jinba Flow and describe the goal in the chat interface. An input such as "Fetch the latest product pages from example.com and extract the title, price, and description" is sufficient for Jinba to generate an initial workflow draft. Review the generated flowchart before proceeding. The draft sets the overall shape; configuration happens at the tool level.

Step 2: Add and configure the TinyFish tool

In the visual flowchart editor, add TinyFish as a step in the sequence. The TinyFish tool documentation lists the available parameters. At minimum, configure:

• URL: the target page or a dynamic variable drawn from an earlier step
• Output format: Markdown for LLM-readable summaries, JSON for structured downstream processing, or HTML if the consuming system requires it
• Search query (optional): when the goal is discovery rather than a known URL

Each tool step executes in its own sandbox within Jinba Toolbox, so a failure in TinyFish does not cascade into the broader workflow without explicit handling.

Step 3: Route output to downstream systems

The TinyFish step returns its structured payload to the workflow as a variable. That variable connects to the next step in the flowchart. Common routing patterns include:

• Passing JSON output to a data transformation step before loading into a database
• Sending Markdown output directly to an LLM step for summarisation or classification
• Routing extracted fields into a CRM update, a Slack message, or a Notion page via Jinba's pre-built integrations

Jinba supports connections to HubSpot, Gmail, Slack, Salesforce, and over 100 other services. The integration is configured at the step level, not at the workflow level, so organisations can chain multiple destinations from a single TinyFish fetch.

Step 4: Test and publish

Before deployment, run the workflow in Jinba's testing environment. Verify that the TinyFish step returns the expected format and that downstream steps receive and handle the payload correctly. Once tested, publish the workflow as an API endpoint or schedule it as a batch process. Jinba supports on-premise and private cloud hosting for organisations with data residency requirements.

End users access the published workflow through Jinba App, either via the chat interface or the auto-generated form, without needing access to the underlying flow.

Governance: what the audit log captures

Organisations running AI agents against external web sources face a specific audit challenge. Auditors need to know what an agent read, when it read it, and what happened to that data afterward. When logs are fragmented across different tools and execution environments, demonstrating a clear chain of accountability becomes a multi-week exercise that can block compliance renewals for standards such as PCI-DSS and ISO.

Jinba's centralised audit log addresses this directly. Every workflow execution produces a complete record that captures:

• Who triggered the workflow: the user, role, or API key that initiated the run
• What TinyFish fetched: the URL, the query, and the content returned
• What happened to the output: every downstream step that touched the data, including transformations, integrations, and approvals

This answers the specific questions auditors raise around agentic systems: whether an agent read a resource opportunistically, what information it accessed, and what actions followed. Because the log is centralised rather than distributed across tool-level outputs, it produces a single record rather than a reconstruction from multiple sources.

Role-Based Access Control (RBAC) complements the audit log by restricting which users can trigger sensitive workflows. Organisations can define access policies at the workflow level, limiting web-fetching processes that touch confidential sources to authorised roles only.

Practical applications

The TinyFish integration inside a Jinba workflow fits several recurring operational patterns.

Competitor research at scale. Product teams monitoring competitor pricing or feature updates can build a workflow that fetches a defined list of product pages on a schedule, extracts names, prices, and descriptions in JSON, and loads the results into a dashboard or spreadsheet. The alternative, opening tabs and copying values manually, takes hours per cycle.

Content aggregation for market analysis. Teams tracking industry developments can configure TinyFish to fetch new posts from a set of target blogs or news sources, convert them to Markdown, and pass them to an LLM step for classification and summarisation before routing summaries to Slack or a knowledge base. The TinyFish production-grade web fetching blog post documents how the dual-layer architecture handles the JavaScript-heavy pages common on modern publishing platforms.

Real-time data aggregation. Workflows that monitor live sources, such as public financial data, regulatory update pages, or job boards, can run on a trigger or schedule, aggregate results across multiple URLs in a single execution, and push structured output to a database or reporting tool.

Each of these scenarios benefits from the same governance foundation: a centralised audit log that records every fetch, every extraction, and every downstream action, without requiring additional instrumentation.

What to do next

Organisations ready to implement this workflow need two things: a TinyFish API key and a Jinba account.

Register for a TinyFish API key at agent.tinyfish.ai and review the TinyFish Fetch API documentation to understand the available parameters and output formats. Then open Jinba Flow, describe the first web-fetching process, add the TinyFish step, and configure the output routing. The Jinba documentation covers the full platform, including toolbox configuration and audit log access.

Start with a single URL and a single downstream destination. Confirm the audit log captures the execution record as expected. From there, the workflow scales to handle multiple sources, branching logic, and enterprise integration requirements without changes to the governance layer.

Frequently Asked Questions

What is the TinyFish integration in Jinba?

TinyFish is a purpose-built AI web agent that Jinba workflows use to fetch and extract content from live web pages. It handles JavaScript rendering, removes clutter, and returns structured data in Markdown, HTML, or JSON. This allows operations teams to automate web data collection within a governed orchestration platform instead of managing separate scrapers.

How do I configure TinyFish inside a Jinba workflow?

In Jinba Flow, describe the web-fetching goal, add a TinyFish tool step in the flowchart editor, configure the target URL or search query, choose an output format, and connect the result to the next step. Once tested, publish the workflow as an API or batch process.

How does TinyFish handle JavaScript-rendered pages?

TinyFish uses a Chromium rendering pool to fully execute JavaScript before extraction, so content that basic HTTP scrapers miss is captured. The extraction layer then converts the rendered page into clean structured data, avoiding blank responses from modern client-side sites.

What output formats does the TinyFish Fetch API support?

The TinyFish Fetch API returns extracted content in Markdown, HTML, or JSON. Markdown suits LLM processing, JSON supports structured storage and integrations, and HTML works for systems that need the original markup. Jinba passes the selected format directly to downstream workflow steps.

Can I use Jinba and TinyFish for competitor research or content aggregation?

Yes. Organisations can schedule TinyFish workflows to fetch competitor product pages, extract fields such as price and description into JSON, and send the results to dashboards or spreadsheets. For content aggregation, teams can fetch target blogs, convert the content to Markdown, summarise it with an LLM step, and route the output to Slack or a knowledge base.

How does Jinba’s audit log track TinyFish web fetches?

Every TinyFish fetch inside Jinba produces a centralised audit record showing who triggered the workflow, which URLs were accessed, what content was returned, and every downstream action that touched the data. This supports compliance reviews for frameworks such as PCI-DSS and ISO without manual log stitching.

Does TinyFish protect against SSRF or internal network requests?

Yes, the TinyFish Fetch API includes SSRF protections that block fetches to internal or risky URLs. This prevents agent workflows from accidentally reaching private infrastructure when they process external web sources.

What is the difference between calling the TinyFish API directly and using it in Jinba?

A direct API call requires managing authentication, retries, and output handling independently. Inside Jinba, TinyFish becomes a managed tool step: operators configure inputs, and the platform routes the structured output to any of over 100 integrations while capturing execution data in the audit log.