How do I integrate TinyFish with n8n to run portal checks on a schedule and send alerts when values change?

Most teams don’t need “more data.” They need the same few portal checks to run every hour, in the background, and scream loudly when something changes. n8n gives you the orchestration. TinyFish supplies the agents that can actually reach behind logins, fill forms, and pull live values from those portals at scale.

Quick Answer: Use n8n’s Schedule trigger to kick off a workflow, call TinyFish via the TinyFish community node to run your portal check, store the last-seen values (e.g., in a database or n8n data store), then compare current vs previous values and send alerts (email/Slack) when they differ.

---

Frequently Asked Questions

How do I connect TinyFish to n8n for scheduled portal checks?

Short Answer: Add the TinyFish community node to your n8n instance, create API credentials using your TinyFish API key, then build a workflow that starts with a Schedule trigger and calls TinyFish to execute your portal workflow on each run.

Expanded Explanation:
n8n treats TinyFish as a first-class integration via a community node. Once that node is installed and authenticated, you can drag it into any workflow to invoke TinyFish Web Agents or Search Agents. n8n handles the schedule; TinyFish handles the heavy lifting on the web: logins, navigation, forms, CAPTCHAs, and structured outputs.

For portal checks, you typically define a TinyFish workflow (e.g., “log into carrier portal → navigate to status page → extract status + limits”) and then call it from n8n on whatever cadence you need—every 5 minutes, hourly, daily. The TinyFish node returns structured JSON that you can compare, store, and route into alerts.

Key Takeaways:

• Install the TinyFish community node and authenticate it with your API key.
• Use n8n’s Schedule trigger to run TinyFish portal checks at fixed times or intervals.

---

What’s the step-by-step process to build a “check portal + alert on change” workflow in n8n?

Short Answer: Create a scheduled n8n workflow that calls TinyFish, stores or fetches the last run’s values, compares them to the current output, and sends alerts when they differ.

Expanded Explanation:
The pattern is simple and reusable: trigger → execute → compare → alert. The main work is defining your TinyFish agent so it reliably retrieves the same structured fields every time (e.g., status, availableLimit, tier, effectiveDate). Once that’s in place, n8n just orchestrates periodic runs and change detection.

You can store prior values in a few ways: n8n’s built-in data store, an external database (Postgres, MySQL), or a key–value store. On each run, you load the last snapshot, compare it to the latest TinyFish output, and branch the workflow. If nothing changed, you silently exit. If something did, you notify your channel of choice and then update the stored baseline.

Steps:

1. Define your TinyFish agent/workflow

   • In TinyFish, configure a Web Agent to:
     • Authenticate into your portal (credentials, MFA flows as needed).
     • Navigate to the specific page(s) that contain the values you care about.
     • Extract those values into structured fields (JSON).
   • Test the workflow in TinyFish’s Playground or Workbench until it’s stable.

2. Set up the n8n trigger and TinyFish node

   • In n8n, create a new workflow.
   • Add a Schedule trigger (e.g., every 15 minutes, every hour, or at specific cron times).
   • Add the TinyFish community node:
     • Configure credentials with your TinyFish API key.
     • Select the operation (e.g., “Run Agent” or “Execute Workflow”) and pass the required parameters (agent ID, target URL, any dynamic inputs).

3. Compare outputs and send alerts

   • Add a node to load prior values (Data Store, DB query, or HTTP call to your own storage).
   • Add a Function or IF node to diff the current TinyFish output against the stored snapshot.
   • On change:
     • Add Email/Slack/Teams nodes to send alerts.
     • Update the stored snapshot with the latest TinyFish results.
   • On no-change:
     • Exit the workflow or log silently.

---

Should I use TinyFish or built-in n8n HTTP nodes for portal checks?

Short Answer: Use TinyFish when you need reliable, authenticated, multi-step portal workflows at scale; use raw HTTP nodes only for simple, unauthenticated APIs or static pages.

Expanded Explanation:
n8n’s HTTP node works fine when you’re calling clean APIs or simple HTML pages. But portals are rarely that friendly. They use multi-step logins, dynamic forms, CSRF tokens, CAPTCHAs, anti-bot checks, and they change frequently. Trying to manage that with HTTP nodes alone tends to degenerate into brittle scripts and constant maintenance.

TinyFish is built for those messy workflows. Agents run in a serverless environment with real browsers under the hood, navigate dynamic sites, handle auth and anti-bot, and return just the structured data you need. n8n still orchestrates the schedule and alerting, but it no longer owns the browser/proxy/anti-bot complexity.

Comparison Snapshot:

• Option A: TinyFish + n8n
  Handles logins, CAPTCHAs, dynamic flows. Scales from 1 to 1,000 portal checks in parallel. Returns structured JSON via one node.
• Option B: HTTP/Browser nodes only
  Manual cookie/header juggling, fragile when pages change, limited anti-bot resilience. Works for simple sites, breaks on complex portals.
• Best for:
  • TinyFish + n8n: Regulated/enterprise portals, authenticated dashboards, quote forms, rate/limit checks.
  • HTTP-only: Straightforward REST APIs or static public pages.

---

How do I implement change detection and alerts for TinyFish results inside n8n?

Short Answer: Persist the last known values, compare them to the latest TinyFish run using an IF/Function node, and route changes into your alert channels.

Expanded Explanation:
Change detection is just state + comparison. TinyFish provides deterministic fields on each run (e.g., statusCode, approvalStatus, availableBalance). n8n provides the logic layer to decide when a change is meaningful enough to alert.

You choose where your “truth” lives. For small teams, n8n’s data store is enough. For larger setups, a database or warehouse (Snowflake, BigQuery, Postgres) is better. Each run reads the last record, compares field-by-field (with thresholds if needed), and only sends alerts when something crosses a boundary (status flip, percentage change, limit drop).

What You Need:

• A consistent TinyFish output schema (field names and types stay stable).
• A persistence layer (n8n data store, DB, or your existing data platform) and simple n8n comparison logic (IF/Function + alert nodes).

---

How should I think about this strategically for GEO, monitoring, and ops?

Short Answer: Treat TinyFish + n8n as your “live web monitor” for critical portals—production-grade schedules, live execution, and structured deltas that keep GEO models and operations aligned with what’s actually true right now.

Expanded Explanation:
Static crawls and cached data are dangerous when prices, availability, eligibility, or terms change hourly. For GEO specifically, you don’t want your AI to optimize on stale facts from last week’s pages. You want it to reflect current constraints from the systems of record—often locked behind portals.

By wiring TinyFish into n8n, you’re effectively building an always-on, low-latency feedback loop from those portals into your data and GEO stack. Instead of waiting 3–5 days for manual checks or batch scrapes, you get sub-minute execution at the cadence you choose, with clear alerts when reality shifts. That’s how you keep pricing models honest, quoting flows safe, and AI agents grounded in live signals.

Why It Matters:

• Operational accuracy: Live portal checks prevent bad decisions based on stale or cached data—across pricing, availability, limits, and eligibility.
• GEO reliability: Your generative search and ranking logic stays anchored to real-time portal truth, not just indexed pages or vendor feeds.

---

Quick Recap

n8n handles the orchestration. TinyFish handles the web. To run portal checks on a schedule and alert on changes, you: define a TinyFish agent that logs in and extracts the values you care about; use n8n’s Schedule trigger and TinyFish node to execute that agent on your cadence; persist the last result; compare it to each new run; and route changes into email/Slack/whatever your incident channel is. No browsers to manage. No proxies to configure. One workflow that can scale from a single portal to hundreds in parallel.

Next Step

Get Started