14 posts tagged with "workflow"

Need a workflow that runs the moment someone adds a row to your trading journal, updates a watchlist price, or deletes an expired entry? The new List Change Trigger does exactly that — it watches a User List and fires your workflow whenever rows are added, updated, or deleted.

No polling, no manual kicks, no cron jobs guessing when data changes.

What Is the List Change Trigger?​

The List Change Trigger is a new node type in the Triggers category of the left sidebar. Drag it onto your canvas, pick which list to watch and which operations matter to you, click Run Test, and you are done.

From that moment on, whenever the watched list changes — through the UI, through the User Lists worker in another workflow, or through the API — your workflow fires automatically with the updated data passed in as context variables.

Reactive, Not Polling​

Under the hood, list mutations publish events to a Redis Stream, and a background listener picks them up using XREAD BLOCK — the same efficient mechanism used by message queues. There is no polling, no wasted compute, and near-zero latency (typically under 5 seconds).

Key Features​

• List autocomplete — start typing your list name and the dropdown finds it instantly
• Multi-select trigger operations — choose exactly which changes matter: add_row, update_rows, delete_row, or any combination
• Optional DSL filter — only fire the workflow when rows matching a condition are affected (e.g. only when status eq active AND price gt 100)
• Pass list data — toggle to include the full list rows in the context variables so downstream workers can process them immediately
• Operation filtering — if you only care about updates, the trigger ignores adds and deletes

How to Use It​

Finding the Worker​

Look in the Triggers category in the left sidebar, or search for "list change". The node has a 📋 icon with a pulse indicator showing it monitors for changes.

Adding to Your Workflow​

1. Drag the List Change Trigger node onto the canvas
2. Connect it to the rest of your workflow nodes
3. Configure — click the node to open the right panel

Configuration​

Run Test​

Click Run Test on the trigger node. This saves the configuration and returns:

• Status — active if everything is set up correctly
• List name — confirmation of which list is being watched
• Trigger operations — which changes will fire the workflow
• Row count — how many rows the list currently has

Once saved, the trigger is live — any matching change to that list will start a workflow run.

Context Variables​

The following variables are available in downstream nodes when the trigger fires:

Use Cases​

Reactive Trading Journal​

When you update a trade's P&L in your journal list, the workflow recalculates performance metrics, updates a dashboard widget, and sends a Telegram summary.

[Journal List Update] → [List Change Trigger]
  → [Calculate Metrics] → [Update Dashboard] → [Send Summary]

Watchlist Price Monitor​

A market data worker periodically updates prices in a watchlist. Every time a price changes, the List Change Trigger fires a workflow that checks for breakout signals, evaluates risk, and alerts you.

[Price Updater Worker] → [Update Watchlist] → [List Change Trigger]
  → [Check Breakouts] → [Evaluate Risk] → [Send Alert]

Multi-Step Data Pipeline​

A data collection workflow adds rows to a source list. The List Change Trigger detects the new rows and kicks off a processing pipeline — enriching, analyzing, and storing results in another list.

[Data Collection] → [Add Rows to Source List] → [List Change Trigger]
  → [Enrich Data] → [AI Analysis] → [Store in Result List]

Approval Workflow​

A team member adds a row with status: "pending_approval" to a shared list. The trigger fires, the workflow checks the DSL filter (status eq pending_approval), runs validation, and sends a Slack or email notification to the approver.

[List Change] → [DSL Filter: status eq pending_approval] → [Validate]
  → [Notify Approver via Telegram/Slack]

Audit Trail​

Track every change to critical lists. The trigger fires on every operation, logs the change to a second list or MongoDB collection, and keeps a full audit history.

[Any List Change] → [List Change Trigger] → [Log to Audit List]
  → [Alert on Suspicious Changes]

Workflow Patterns​

Single-Trigger Standalone​

The simplest setup: one trigger, one workflow. Good for simple reactions.

[List Change] → [List Change Trigger] → [Process Data] → [Output]

Chained Triggers​

Multiple workflows can watch the same list with different filters. Workflow A handles add_row for new entries, Workflow B handles status eq active updates only.

[Same List]
  ├─ [Trigger A: add_row] → [New Entry Handler]
  └─ [Trigger B: update_rows + DSL filter] → [Active Item Processor]

Hybrid Timed + Reactive​

Use the Schedule Trigger for periodic maintenance runs and the List Change Trigger for immediate reactions. Both point to shared downstream logic.

[Schedule Trigger (hourly)] → [Shared Logic: Validate → Clean → Report]
[List Change Trigger (instant)] → [Shared Logic: Validate → Clean → Report]

Parameter Loop + List Change​

A Parameter Loop worker generates multiple configurations and stores them in a list. Each new row triggers a separate workflow run that backtests that configuration.

[Parameter Loop] → [Add Row to Config List] → [List Change Trigger (per row)]
  → [Backtest Config] → [Store Results]

Best Practices​

• Be specific with operations — if you only care about updates, uncheck add_row and delete_row. This keeps your workflows focused and avoids unnecessary runs.
• Use DSL filters for large lists — if your list has hundreds of rows but you only care about rows with status eq active, set the filter. The triggered workflow receives matchedRows — only the relevant subset.
• One trigger per (workflow, list) pair — you can have multiple workflows watching the same list, but only one trigger per workflow-list combination.
• Pass list data — keep this enabled unless your list is extremely large. It saves a DB round-trip in downstream workers.
• Test with Run Test — the "Run Test" button saves the trigger config and returns a summary. Make a change to the list and your workflow should fire within seconds.

How It Works (Architecture)​

User List Mutation (UI / Worker / API)
  → publish_list_change_event()
  → XADD to Redis Stream "apudflow:stream:list-change-events"
  → Listener (XREAD BLOCK, 5s timeout)
  → Find matching subscriptions in MongoDB
  → Check triggerOn matches operation
  → Evaluate DSL filter (if set)
  → Create workflow run with context vars
  → Push to workflow queue
  → Executor picks up and runs the workflow

The entire pipeline is asynchronous and event-driven. There is no blocking, no polling, and no performance impact on the list mutation itself.

Legal Disclaimer​

This is not financial advice. Trading involves significant risk of loss. Use reactive workflows at your own discretion.

You've built a library of workflows — data pipelines, signal generators, backtesters, alert senders. Until now, each one ran in isolation. The new Run Workflow worker changes that: trigger any workflow from inside another workflow, pass variables between them, and (optionally) wait for results.

This turns your workflows into reusable building blocks — your data-processing workflow becomes a function call, your backtest runner becomes a sub-process, your entire analysis chain becomes a single parent workflow.

What Is the Run Workflow Worker?​

The Run Workflow worker lives in the Flow category of the left sidebar. Drag it onto your canvas, select a target workflow (via autocomplete), optionally pass variables, and choose a mode. That's it.

It's a flow-control node — it orchestrates other workflows rather than processing data itself.

Key Features​

• Autocomplete target selection — search and pick any of your workflows by name
• Variable passing — send key-value data that becomes available in the target workflow as {{ variable }}
• Two execution modes — fire-and-forget for parallel execution, wait-for-result for sequential chaining
• Timeout control — in wait mode, configure how long to wait (10–600 seconds)
• Full result capture — wait mode returns every node's output from the target workflow

How to Use It​

Finding the Worker​

Look in the Flow category in the left sidebar, or search for "run workflow". The node shows a play-arrow icon with a gear.

Adding to Your Workflow​

1. Drag the Run Workflow node from the left sidebar onto your canvas
2. Connect it to preceding nodes (e.g., a trigger or data source)
3. Click the node — the right panel opens with configuration fields
4. Select target workflow — the autocomplete field lets you search by name

Configuration​

Passing Variables​

Any variables you pass become available in the target workflow's context. For example, if you pass:

{
  "symbol": "BTCUSD",
  "timeframe": "1h",
  "limit": 200
}

The target workflow can reference them as {{ symbol }}, {{ timeframe }}, and {{ limit }} in any downstream node — just like webhook trigger variables.

Mode Comparison​

Workflow Chaining Patterns​

1. Simple Trigger Chain (Fire-and-Forget)​

[Manual Trigger] → [Run Workflow "Fetch Data"] → [Run Workflow "Send Alert"]

The parent workflow triggers "Fetch Data" and "Send Alert" — both run independently.

2. Data Pipeline (Wait-for-Result)​

[Schedule Trigger] → [Run Workflow "Fetch & Clean Data" (wait)] → [Run Workflow "Generate Signals" (wait)] → [Run Workflow "Store Results"]

Each step waits for the previous one to finish. The parent orchestrates a multi-stage pipeline.

3. Fan-Out / Parallel Processing​

[Trigger] → [Run Workflow "Analyze BTC" (fire-and-forget)]
         → [Run Workflow "Analyze ETH" (fire-and-forget)]
         → [Run Workflow "Analyze SOL" (fire-and-forget)]

All three analysis workflows launch simultaneously — great for multi-symbol scans.

4. Reusable Report Generator​

[Webhook Trigger] → [Fetch Data] → [Process Signals] → [Run Workflow "Generate Report" (wait)] → [Telegram Notify]

The "Generate Report" workflow is shared across many parent workflows — write once, reuse everywhere.

Financial Markets Applications​

Strategy Pipeline​

[Schedule Trigger] → [Run Workflow "Fetch OHLCV Data" (wait)]
                   → [Run Workflow "Compute Indicators" (wait)]
                   → [Run Workflow "Run Backtest" (wait)]
                   → [Telegram Send Results]

Chain your data-fetching, indicator, and backtest workflows together. Each is independently testable and reusable.

Multi-Symbol Analysis​

[Trigger] → [Parameter Loop] → [Run Workflow "Analyze Symbol"]

Use a Parameter Loop to iterate over symbols, passing each one to a shared analysis workflow via variables. Collect results in a final aggregation step.

Output​

Fire-and-Forget​

• run_id — the ID of the triggered run (use to track progress)
• targetWorkflowName — name of the triggered workflow
• passedVariables — the variables that were passed along

Wait-for-Result (all of the above, plus)​

• targetStatus — finished, failed, error, or cancelled
• targetResults — object mapping each node name to its output
• targetFinishedAt — timestamp of completion

Tips​

• Name your workflows clearly — the autocomplete shows workflow names. Descriptive names make selection faster.
• Use wait mode for dependencies — if step B needs step A's output, use wait-for-result.
• Use fire-and-forget for independence — if steps don't depend on each other, let them run in parallel.
• Watch timeouts — complex target workflows may need more than 300s. Adjust the timeout parameter in expert settings.
• Variable names matter — pass variables with names that match what the target workflow expects.

Legal Disclaimer​

This is not financial advice. Trading involves risk of financial loss. The Run Workflow worker is a tool for automation — you are responsible for the logic and outcomes of your workflows.

Need to kick off a workflow from an external system — a CI/CD pipeline, a trading signal provider, a custom script, or even another ApudFlow workflow? The new Webhook Trigger worker lets you do exactly that: expose an HTTP endpoint that starts your workflow on demand.

Unlike the Schedule Trigger (which runs on a timer), the Webhook Trigger is passive — it waits for an incoming HTTP call, then passes the caller's data straight into your workflow as context variables.

What Is the Webhook Trigger?​

The Webhook Trigger is a new node type in the Triggers category of the left sidebar. Drag it onto your canvas, define the variables you expect from the caller, click Run Test, and you get a stable URL like:

POST /api/t/{workflow_id}/{webhook_id}

Any external system — or even another workflow — can call that URL and your workflow runs with the data it sent.

Key Features​

• Both POST and GET — send variables in a JSON body (POST) or as query parameters (GET)
• Typed variables — define each variable as string, integer, boolean, or list with validated choices
• Required / optional — mark variables as required; the endpoint rejects calls that miss them
• Default values — if a variable isn't provided, the default kicks in
• Optional API key — secure the endpoint with a bearer token (or leave it open)
• Isolated path — uses /api/t/ prefix, separate from the existing data provider endpoints under /api/w/

How to Use It​

Finding the Worker​

Look in the Triggers category in the left sidebar, or search for "webhook". The node has a distinctive lightning-bolt icon with an outgoing arrow.

Adding to Your Workflow​

1. Drag the Webhook Trigger node onto the canvas
2. Connect it to the rest of your workflow nodes
3. Configure variables — click the node and the right panel shows a visual variable editor

The Variable Editor​

Each variable is a card with:

Below the variable cards there's an optional API Key field — leave it blank for an open endpoint, or set a secret key to restrict access.

Run Test​

Click Run Test on the trigger node. This saves the configuration and returns:

• The endpoint URL you can share with external systems
• The variables you defined, each shown as a top-level output field with its default value
• The status — success if everything is configured correctly

Calling the Endpoint​

POST (recommended for complex data)​

curl -X POST "https://api.apudflow.io/api/t/{workflow_id}/{webhook_id}" \
  -H "Content-Type: application/json" \
  -d '{"symbol": "BTCUSD", "limit": 100, "mode": "backtest"}'

GET (quick tests / simple values)​

curl "https://api.apudflow.io/api/t/{workflow_id}/{webhook_id}?symbol=BTCUSD&limit=100&mode=backtest"

If you set an API key, pass it as an Authorization: Bearer <key> header or api_key=<key> query parameter.

Variable Resolution Priority​

1. Values from the request (highest priority)
2. Default values from the trigger configuration
3. Empty string if neither is provided and the variable is optional

Use Cases​

External Trading Signal Execution​

A trading signal provider (e.g. MetaTrader, TradingView webhook, custom bot) calls your workflow with symbol, direction, and position size — your workflow validates, logs, and executes.

[TradingView Alert] → HTTP POST → [Webhook Trigger] → [Validate] → [Execute Trade] → [Log Results]

CI/CD Pipeline Trigger​

After a deploy, your pipeline calls the webhook with the build version and environment — your workflow runs tests, sends notifications, and updates dashboards.

[CI/CD Pipeline] → HTTP POST → [Webhook Trigger] → [Run Tests] → [Send Notification]

Worker-to-Workflow Communication​

One workflow's final node (e.g. a Signal Generator or AI Analyzer) triggers another workflow by calling its webhook URL. This decouples large automations into manageable sub-workflows.

[Workflow A: Data Collection] → [AI Analysis] → HTTP POST → [Workflow B: Execution]

Scheduled + Webhook Hybrid​

Use the Schedule Trigger for regular runs (e.g. every hour) and the Webhook Trigger for ad-hoc event-driven runs — both point to the same downstream logic.

Best Practices​

• Set an API key if the endpoint is exposed to the internet — otherwise anyone who knows the URL can trigger your workflow
• Use typed variables — mark boolean and integer fields with matching types so the endpoint validates incoming data
• Default values are your safety net — set sensible defaults so the workflow runs even if the caller omits a field
• Test with curl first before integrating into a production system

Legal Disclaimer​

This is not financial advice. Trading involves significant risk of loss. Use webhook-triggered workflows at your own discretion.

The gap between "this strategy looks good in backtest" and "this strategy is running live" is where most trading ideas die. You optimized the parameters, saved the results, and then what? Manually type the numbers into a live workflow? Run the full sweep on every trigger?

The Parameter Loop worker was designed to bridge that gap. Here's how to go from sweeping to shipping in one workflow.

The Three-Mode Philosophy​

Every Parameter Loop node has a prodMode dropdown with three options — and choosing the right one for each stage of development is the key to a smooth deployment pipeline.

Development Mode: prodMode = disabled​

What happens: During manual "Run Test", the full sweep executes. During scheduled/webhook runs, the node is skipped (returns immediately).

When to use: When you're still exploring. You want full control — run sweeps manually, inspect results, refine the parameter grid, iterate.

Best practice: Set disabled for the first 10-20 sweeps while you narrow down the optimal region.

Staging Mode: prodMode = use_best​

What happens: During "Run Test", the full sweep executes as normal. During scheduled runs, the worker loads the best parameters from the most recent saved session and uses them directly — no sweep runs.

When to use: Once you've found a good parameter set and want to use it in production, but still want the ability to re-sweep manually on demand.

How it works under the hood:

1. Your last successful sweep saved a session (because you set sessionLabel)
2. The session contains bestParameters and bestValue
3. On production triggers, use_best loads bestParameters and writes them into the worker's vars
4. The strategy executes with optimized values — no computational waste

Power Mode: prodMode = always_run​

What happens: The sweep runs every single time — whether manual test, schedule, or webhook.

When to use: Rarely. Only when market regimes change fast enough that yesterday's optimum is today's loser, and you have enough compute budget to run a full sweep every 15 minutes.

The Complete Pipeline​

┌─────────────────────────────────────────────────────────────────┐
│                         Development                             │
│  prodMode: disabled                                              │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌───────────┐ │
│  │ Coarse   │───▶│ Inspect  │───▶│ Fine     │───▶│ Inspect   │ │
│  │ Sweep    │    │ Results  │    │ Sweep    │    │ Results   │ │
│  └──────────┘    └──────────┘    └──────────┘    └───────────┘ │
│  3×3 grid                         3×3 refined grid              │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                         Production                               │
│  prodMode: use_best                                              │
│  ┌──────────┐    ┌──────────────┐    ┌────────────────────────┐ │
│  │ Schedule │───▶│ Parameter    │───▶│ Strategy runs with     │ │
│  │ Trigger  │    │ Loop (loads  │    │ best parameters from   │ │
│  │          │    │ best params) │    │ saved session          │ │
│  └──────────┘    └──────────────┘    └────────────────────────┘ │
│                                        No sweep overhead         │
└─────────────────────────────────────────────────────────────────┘

Example: The Session Lifecycle​

Step 1 — Run a Sweep (Dev)​

Parameter Loop → Run Test
Session Label: "eurusd_swing_q2_2026"

25 iterations complete. Best result: stop_loss=2.5, take_profit=4.0, sharpe=1.87.

The session is saved to the Sessions tab. You can revisit it anytime.

Step 2 — Pinned Deployment​

Switch to prodMode: use_best.

To be extra safe, optionally add pinnedBestParameters:

"pinnedBestParameters": {
  "stop_loss": 2.5,
  "take_profit": 4.0
}

Pinned parameters take priority over the saved session — useful if you've manually verified the values and don't want any risk of loading a wrong session.

Step 3 — Schedule It​

Add a Schedule Trigger to the workflow:

{
  "everySeconds": 3600,
  "type": "interval"
}

Every hour, the workflow runs. The Parameter Loop loads the best parameters, the Backtest runs with those values, and your strategy stays optimized without consuming compute on unnecessary sweeps.

Handling Regime Changes​

Markets change. The parameters that worked in a trending market may fail in a ranging one.

The fix: Every week (or month), run a manual sweep to verify the current parameters are still optimal. If the results shift significantly, save a new session — production automatically picks up the latest session on the next scheduled run.

What You Get​

One Parameter Loop node. Three modes. A complete path from discovery to deployment.

The takeaway: Don't re-invent strategy deployment. The Parameter Loop's production modes handle it — so you can focus on building strategies, not plumbing.

Your strategy's stop loss works great on Gold — but how does it hold up on Bitcoin? Will the same take-profit target that nails EURUSD also work for GBPJPY? Until now, you had to guess, or run separate workflows for every symbol and stitch the results together manually.

One Sweep, Multiple Symbols​

The Parameter Loop worker doesn't care what symbols your strategy trades. Connect a multi-symbol data fetcher and your strategy runs exactly the same way for every asset — but the Parameter Loop adds a second dimension: it also sweeps the parameters.

The result is a 3D optimization grid:

Symbol × Stop Loss × Take Profit = Total Iterations
   3    ×     5     ×      5      =      75

Every combination runs automatically. The best parameter set for XAUUSD might be different from the best set for BTCUSD — and the results table shows you both.

Workflow: Multi-Symbol Risk Optimization​

[Trigger] → [Fetch Prices (XAUUSD, BTCUSD, EURUSD)] → [Swing Finder] → [Backtest] → [Parameter Loop]

Step 1: Fetch Multi-Symbol Data​

Your Fetch Prices worker pulls OHLC data for all three symbols:

{
  "symbols": ["XAUUSD", "BTCUSD", "EURUSD"],
  "timeframe": "1h",
  "limit": 2000
}

The Swing Finder detects swing points across all three independently. The Backtest evaluates each symbol's signals separately and returns combined statistics.

Step 2: Configure the Sweep​

In the Parameter Loop's two-column dialog, set up the grid:

Sweep parameters:

[
  {"name": "stop_loss",   "values": [1.0, 2.0, 3.0, 4.0, 5.0]},
  {"name": "take_profit", "values": [2.0, 3.0, 4.0, 5.0, 6.0]}
]

Ranking: Collect result.sharpe_ratio, rank by max.

Step 3: Read the Results​

The results table shows every combination for every symbol. You can instantly see:

The best combination works across all three symbols — not just one. This is portfolio-level optimization in a single click.

When to Use Multi-Symbol Sweeps​

Live Production: Auto-Deploy Per-Symbol Parameters​

Save the sweep results as a session, then set the Backtest's Production Mode to use_best. On every scheduled run, the optimized parameters load automatically — no re-sweep needed.

The takeaway: One workflow, one sweep, unlimited symbols. Stop guessing which parameters work where — let the Parameter Loop find out.

Strategies are easy to invent and hard to tune. The same trading idea can be profitable with one combination of (stop_loss, take_profit, size) and a money pit with another. Until now ApudFlow forced you to either hand-pick numbers or write one-off Python scripts (sweep_workflow.py, optimize_swing_strategy.py) outside the platform. The new Parameter Loop worker changes that — you describe the parameter grid once, click Run sweep, and watch every iteration stream into a results table inside the workflow editor.

What it does​

Parameter Loop runs a single sub-worker multiple times with a different combination of input parameters on every iteration and stores the result of every iteration. The cartesian product of all values lists is executed, so a 3 × 5 grid produces exactly 15 iterations. The result of every iteration is rendered as a row in the right-hand panel of the dialog; the winning iteration (per rankingField / rankingMode) is highlighted in green, failures in red.

It is the worker you reach for when you are trying to answer "which combination of parameters is best?":

• backtest → find the best (stop_loss, take_profit, size) triple
• signal_enricher / signal_generator → sweep indicator thresholds
• python_exec → try many numeric / string configurations of a snippet
• any other worker → pass a different value of one or more parameters on every iteration

A 2-column dialog, by design​

The node has its own custom rendering: a dashed border on the canvas (it is a sink — it has no input handle and no output handle) and a two-column layout inside the dialog. The left column holds the sweep configuration (sub-worker selector, parameter grid, ranking settings); the right column holds the per-iteration results table. There is no "central settings" column and no "output of the previous node" column — neither makes sense for a sweep.

The same rendering mode is now available to any worker that wants it. WorkerDefinition gained a new ui_layout field — set it to "two-column" and the dialog switches to the new layout.

How to set up a sweep​

sweepParameters is a list of {name, values} objects. Every entry defines one parameter to vary:

[
  {"name": "stop_loss",   "values": [1.0, 1.5, 2.0, 2.5, 3.0]},
  {"name": "take_profit", "values": [2.0, 3.0, 4.0, 5.0, 6.0]}
]

The total number of iterations is the cartesian product of the values lists (2 × 5 = 10 in the example above). The values field accepts:

Sub-worker parameters​

subWorkerParameters is the base set of parameters passed to the sub-worker on every iteration. The sweep combination is deep-merged on top of it (the sweep value wins when the keys collide). For example, with:

"subWorkerParameters": {
  "symbol": "XAUUSD",
  "stop_loss": 1.0
},
"sweepParameters": [
  {"name": "stop_loss", "values": [2.0, 3.0]}
]

…the sub-worker will see "symbol": "XAUUSD" on every iteration and "stop_loss" alternating between 2.0 and 3.0.

The sweep values are also reachable from the sub-worker's vars context as vars._sweep (a dict of all sweep values for the current iteration) and vars._sweepIndex / vars._sweepTotal, which is handy when the sub-worker wants to do early-exit logic or label its output.

Collecting & ranking results​

• collectField — dotted path of the field to extract from the sub-worker output (e.g. "result.sharpe"). Leave empty to keep the whole output.
• rankingField — dotted path inside the collected result used to pick the best iteration (e.g. "sharpe_ratio").
• rankingMode — "max" (default) or "min".

The best iteration is exposed as vars.<nodeName>.bestParameters and vars.<nodeName>.bestValue for downstream workers, so you can act on the winner in a follow-up step (run the best parameters through a live trade, log them to a webhook, send a Telegram notification, …).

Safety options​

• continueOnError (default true) — keep going when an iteration throws. Set to false to stop at the first failure.
• maxIterations (default 0 = no cap) — safety cap on the total number of iterations to run (useful to avoid accidentally running a 10 000-iteration sweep on a slow sub-worker).

Output​

{
  "subWorkerType": "backtest",
  "totalIterations": 10,
  "successfulIterations": 10,
  "failedIterations": 0,
  "iterations": [
    {
      "iteration": 1,
      "parameters": {"stop_loss": 1.0, "take_profit": 2.0},
      "result": {"sharpe_ratio": 0.42, "trades": 38},
      "fullOutput": {...},
      "durationMs": 137
    }
  ],
  "bestIteration": 7,
  "bestParameters": {"stop_loss": 2.5, "take_profit": 5.0},
  "bestValue": 1.87,
  "rankingField": "sharpe_ratio",
  "rankingMode": "max"
}

Real-World Example: Gold & EURUSD Swing Strategy Optimization​

Here's a complete workflow that shows Parameter Loop optimizing a multi-symbol swing trading strategy for Gold (XAUUSD) and EURUSD:

[Trigger] → [Fetch Prices] → [Swing Finder] → [Backtest Strategy] → [Parameter Loop]

Setting Up the Sweep​

With the Backtest Strategy connected to the Parameter Loop's left (out) handle, configure the sweep grid in the two-column dialog:

Sweep parameters — test 5 stop-loss values × 5 take-profit values:

[
  {"name": "stop_loss",   "values": [1.0, 1.5, 2.0, 2.5, 3.0]},
  {"name": "take_profit", "values": [2.0, 3.0, 4.0, 5.0, 6.0]}
]

25 total iterations. Each combination runs the complete swing detection + backtest pipeline.

Ranking settings:

• Collect field: result.sharpe_ratio
• Ranking mode: max (higher Sharpe = better)
• Session label: gold_eurusd_swing_v1

Live Results​

As each iteration completes, the right panel updates in real time:

The best iteration (Sharpe 1.87) is highlighted in green. Clicking its row sets stop_loss: 2.5 and take_profit: 4.0 on the Backtest Strategy worker.

Going Live​

Set Production Mode to use_best on the Parameter Loop. Now when your scheduled trigger fires:

• The sweep does not run (avoiding unnecessary computation)
• The best parameters from the saved session are loaded automatically
• The Backtest Strategy executes with the optimized values

Tips & best practices​

• Start with a coarse grid (3 × 3 = 9 iterations) to find the rough optimum, then refine around the winner with a finer grid.
• When the sub-worker is slow, set maxIterations to a small number during development and lift it for the final run.
• Use continueOnError: true while exploring so a single bad combination does not abort the whole sweep.
• Always set a session label — saved sessions let you load results later and enable Production Mode's use_best functionality.
• The Parameter Loop node does not route execution to a downstream graph — it is a sink. If you want to act on the result, read vars.<nodeName>.bestParameters in the next node.

Available today​

Parameter Loop is in the flow category. Drop it onto a canvas, pick the sub-worker, fill in sweepParameters, and the new two-column dialog takes over from there. Happy hunting.

In the demanding world of financial trading, personal organization is crucial for maintaining discipline, managing risk, and achieving long-term success. Stock traders, cryptocurrency investors, and forex professionals often struggle with information overload, scattered data, and inconsistent routines. The Fetch Data with Prices worker, integrated with AI tools like AI Chat, AI Classifier, AI Data Analyzer, and AI Summarizer, provides a comprehensive solution for organizing your trading life, from data management to performance tracking.

The Importance of Organization in Trading​

Trading requires meticulous organization: tracking positions, monitoring markets, recording decisions, and reviewing performance. Poor organization leads to missed opportunities, unmanaged risks, and emotional decision-making. AI-powered organization transforms chaos into clarity, helping traders maintain focus and discipline.

Triggering Organized Workflows​

Well-organized trading workflows begin with consistent triggers:

• Daily Routine Trigger: Initiates morning data reviews and planning sessions
• End-of-Day Trigger: Automates performance logging and next-day preparation
• Portfolio Review Trigger: Scheduled deep dives into holdings and strategies
• Risk Management Trigger: Alerts when positions exceed predefined limits

Building an Organized Trading System with AI​

The Fetch Data with Prices worker centralizes your market data, while AI tools provide intelligent organization and insights:

1. Structured Data Management with AI Classifier​

Automatically organize your trading data:

• Classify trades by strategy, timeframe, and outcome
• Tag positions by risk level and market conditions
• Sort watchlists by priority and opportunity

Practical Example: A stock trader uses AI Classifier to automatically categorize their portfolio into "core holdings," "swing trades," and "speculative positions." This organization helps maintain proper risk allocation and focus attention where needed.

2. Intelligent Performance Tracking with AI Data Analyzer​

Analyze your trading performance comprehensively:

• Track win/loss ratios across different strategies
• Identify patterns in successful vs. unsuccessful trades
• Generate risk-adjusted performance metrics

Tip: Set up a workflow that analyzes your trading journal data alongside market data, revealing how external conditions affect your decision-making.

3. Conversational Organization with AI Chat​

Get organized insights on demand:

• Ask questions like "What's my best-performing strategy this month?"
• Request summaries of your trading activity
• Get reminders for important market events or position reviews

Practical Example: Use AI Chat to ask, "Based on my recent trades, what organizational improvements should I make?" The AI might suggest better position sizing or more disciplined entry criteria.

4. Automated Reporting with AI Summarizer​

Create organized summaries of your trading life:

• Generate weekly performance reports
• Summarize monthly portfolio reviews
• Create organized trade journals automatically

Tip: Configure AI Summarizer to produce "trading health check" reports that combine performance data, risk metrics, and behavioral insights into a single, organized document.

Practical Organization Tips for Traders​

1. Digital Trading Journal: Use AI to automatically log every trade with context, including market conditions, your reasoning, and outcomes.

2. Automated Alerts: Set up triggers for position management, like automatic notifications when stop-loss levels are approached.

3. Routine Standardization: Create template workflows for daily, weekly, and monthly reviews to ensure consistency.

4. Risk Management Dashboards: Build organized views of your risk exposure across all positions and strategies.

5. Goal Tracking: Use AI to monitor progress toward trading goals, adjusting strategies as needed.

Real-World Organization Transformation​

Consider Maria, a cryptocurrency trader who struggled with disorganized trading practices. Her breakthrough came with AI integration:

• Daily Routine Trigger starts her morning workflow
• Fetch Data with Prices pulls crypto market data
• AI Classifier organizes her watchlist by volatility and opportunity
• AI Data Analyzer tracks her performance metrics
• AI Summarizer creates weekly reports
• AI Chat provides insights on her trading patterns

Maria now maintains a perfectly organized trading operation: clear position tracking, consistent risk management, and data-driven decision-making. Her drawdowns have decreased by 40%, and she reports feeling more in control of her trading career.

Maintaining Organizational Discipline​

Successful organization requires ongoing commitment:

• Consistency Over Perfection: Focus on regular, imperfect organization rather than occasional perfect setups
• Review and Adjust: Regularly assess your organizational systems and refine them
• Technology as a Tool: Use AI to enhance, not replace, your organizational skills
• Balance: Avoid over-organization that leads to analysis paralysis

The Organized Trader's Advantage​

In financial markets, organization is a competitive advantage. Well-organized traders make better decisions, manage risk more effectively, and learn from their experiences. AI tools provide the structure and automation needed to maintain this organization consistently.

By starting with triggers that establish routines and integrating AI tools for data management and analysis, traders can create a comprehensive organizational system. This system not only improves immediate performance but also supports long-term growth and development.

Remember, successful trading is as much about personal management as it is about market analysis. With AI-powered organization on ApudFlow, you can build the structured foundation needed for trading excellence.

Invest time in organizing your trading life with AI, and you'll find that clarity leads to confidence, and confidence leads to consistent success. The organized trader doesn't just react to markets—they control their trading destiny.

Creativity in trading goes beyond traditional analysis—it's about discovering novel approaches, combining disparate data points, and developing unique strategies that others overlook. For stock traders, cryptocurrency investors, and forex professionals, the Fetch Data with Prices worker paired with AI tools like AI Chat, AI Classifier, AI Data Analyzer, and AI Summarizer opens up new dimensions of creative exploration. This integration transforms routine data into innovative insights, helping traders break free from conventional thinking.

The Role of Creativity in Financial Markets​

Financial markets reward creativity. While fundamental analysis and technical indicators provide structure, creative traders find edges through unconventional approaches: combining sentiment data with price action, exploring cross-market correlations, or developing proprietary indicators. AI tools amplify this creativity by processing vast amounts of data and suggesting connections humans might miss.

Triggering Creative Workflows​

Creative workflows on ApudFlow start with triggers that capture inspiration moments:

• Market Anomaly Trigger: Initiates workflows when unusual price movements occur, sparking creative investigation.
• Cross-Market Trigger: Fires when correlations between different asset classes change, suggesting new trading ideas.
• Time-Based Creative Sessions: Scheduled triggers for dedicated "innovation time" to explore new strategies.

Fostering Creativity with AI Integration​

The Fetch Data with Prices worker provides the raw material—comprehensive price data across stocks, crypto, and forex. AI tools transform this data into creative fuel:

1. Exploratory Analysis with AI Data Analyzer​

Use AI Data Analyzer to uncover hidden patterns:

• Discover non-obvious correlations between assets
• Identify unique market regimes or cycles
• Generate hypothesis for testing

Practical Example: A cryptocurrency trader fetches price data for 100 altcoins and uses AI Data Analyzer to find unusual correlations. The AI might reveal that certain meme coin prices correlate with social media trends, inspiring a sentiment-based trading strategy that combines price data with social metrics.

2. Idea Generation with AI Chat​

Leverage conversational AI for brainstorming:

• Ask "What if" questions about market scenarios
• Explore alternative interpretations of data
• Generate novel strategy combinations

Tip: After fetching forex data, ask AI Chat: "If EUR/USD breaks this resistance level, what creative ways could I profit from the resulting volatility?" The AI might suggest options strategies, correlated currency pairs, or timing-based approaches you hadn't considered.

3. Categorizing Creative Opportunities with AI Classifier​

Automatically sort and prioritize innovative ideas:

• Classify trading opportunities by creativity level
• Tag strategies as "conventional," "innovative," or "experimental"
• Filter for high-potential creative approaches

Practical Example: Classify potential trades based on how unique the setup is. A stock trader might find that AI Classifier labels a strategy combining earnings data with satellite imagery of parking lots as "highly creative," prompting deeper exploration.

4. Synthesizing Insights with AI Summarizer​

Condense complex ideas into clear concepts:

• Summarize multi-asset analysis into unified themes
• Create abstracts of novel trading approaches
• Distill creative insights for quick review

Tip: Use AI Summarizer to create "strategy abstracts" that capture the essence of your most creative ideas, making it easier to revisit and refine them over time.

Practical Tips for Creative AI Integration​

1. Diverse Data Sources: Don't limit yourself to price data—combine Fetch Data with Prices output with news feeds, social media, or economic indicators for truly creative strategies.

2. Hypothesis Testing Loops: Create workflows that generate hypotheses, test them against historical data, and refine based on results.

3. Creative Constraints: Set artificial constraints (like "trade only blue-chip stocks with crypto correlations") to force innovative thinking.

4. Collaborative Ideation: Use AI Chat to simulate discussions with other traders or experts, gaining new perspectives on your strategies.

5. Iterative Refinement: Build workflows that automatically iterate on creative ideas, testing variations and improvements.

Real-World Creative Breakthroughs​

Meet Alex, a forex trader who was stuck in traditional trend-following strategies. By integrating AI into his workflow:

• Market Anomaly Trigger detects unusual EUR/GBP movements
• Fetch Data with Prices pulls comprehensive currency data
• AI Data Analyzer finds correlations with commodity prices
• AI Chat suggests combining forex trades with commodity futures
• AI Classifier categorizes the strategy as "highly innovative"

Alex develops a "commodity-currency nexus" strategy, profiting from the interplay between oil prices and currency movements. This creative approach increases his win rate by 25% and opens new revenue streams.

Overcoming Creative Blocks​

AI integration can sometimes lead to over-reliance on algorithms. Here's how to maintain creative control:

• Human Oversight: Always apply your market experience to AI suggestions
• Diverse AI Inputs: Use multiple AI tools to get varied perspectives
• Intuition Validation: Test AI-generated ideas against your gut feelings
• Incremental Innovation: Start with small creative tweaks rather than complete overhauls

The Creative Edge in Trading​

In competitive financial markets, creativity separates good traders from great ones. AI tools don't replace human ingenuity—they amplify it, providing the data processing power to explore ideas that would be impossible manually.

By starting with triggers that capture market opportunities and integrating AI tools for analysis and ideation, traders can unlock new levels of creative strategy development. The combination of comprehensive price data with intelligent analysis creates an environment where innovation thrives.

Remember, the most successful traders are those who continuously evolve their approaches. With AI-powered workflows on ApudFlow, you have the tools to push the boundaries of what's possible in trading, discovering strategies that others can't even imagine.

Embrace the creative potential of AI integration, and watch as your trading strategies evolve from conventional to extraordinary. The future of trading belongs to those who can harness technology to fuel their creative vision.

In the fast-paced world of financial trading, productivity is the key to staying ahead. Stock traders, cryptocurrency enthusiasts, and forex professionals know that timely access to accurate data can make or break their strategies. The Fetch Data with Prices worker, when combined with AI tools like AI Chat, AI Classifier, AI Data Analyzer, and AI Summarizer, transforms how traders manage their workflows, automate routine tasks, and focus on high-impact decisions.

Understanding Productivity in Trading​

Productivity in trading isn't just about working harder—it's about working smarter. Traders juggle multiple tasks: monitoring markets, analyzing data, executing trades, and managing risks. Manual data collection and analysis can consume hours, leaving little time for strategic thinking. By integrating AI into your routines, you can automate data fetching and processing, freeing up mental bandwidth for creative decision-making.

Starting with Triggers: The Foundation of Efficient Workflows​

Every effective workflow on ApudFlow begins with a trigger. For productivity-focused traders, consider these starting points:

• Schedule Trigger: Set up daily or hourly data fetches to keep your analysis current without manual intervention.
• Price Alert Trigger: Automatically initiate workflows when specific price thresholds are met, ensuring you never miss critical market movements.
• News Event Trigger: Kick off data collection when relevant news breaks, allowing immediate analysis of market reactions.

Integrating Fetch Data with Prices and AI Tools​

The Fetch Data with Prices worker serves as your data pipeline, pulling OHLC (Open, High, Low, Close) data for stocks, cryptocurrencies, and forex pairs. Here's how to combine it with AI tools for maximum productivity:

1. Automated Data Analysis with AI Data Analyzer​

Connect Fetch Data with Prices to the AI Data Analyzer for instant insights:

• Fetch hourly price data for your watchlist
• AI Data Analyzer processes patterns, trends, and anomalies
• Receive automated reports on market conditions

Practical Example: A forex trader monitoring EUR/USD can set up a workflow that fetches 15-minute data every hour. The AI Data Analyzer identifies potential reversal patterns, classifying them as "bullish," "bearish," or "neutral." This automation allows the trader to focus on executing trades rather than manual chart analysis.

2. Intelligent Classification with AI Classifier​

Use AI Classifier to categorize market data automatically:

• Classify price movements by volatility levels
• Sort assets by risk categories
• Tag data points for specific trading strategies

Tip: Create a workflow that classifies cryptocurrency price data into "high volatility," "moderate," and "low volatility" categories. This helps traders prioritize their attention on assets most likely to provide trading opportunities.

3. Conversational Insights with AI Chat​

Integrate AI Chat for on-demand analysis:

• Ask natural language questions about your data
• Get explanations of complex market patterns
• Brainstorm trading ideas based on current data

Practical Example: After fetching daily stock data, use AI Chat to ask, "What are the strongest bullish signals in this dataset?" The AI provides conversational responses, helping traders quickly understand key insights without deep technical analysis.

4. Summarized Market Intelligence with AI Summarizer​

Condense large datasets into actionable summaries:

• Generate daily market recaps
• Summarize weekly performance reports
• Create executive summaries for portfolio reviews

Tip: Set up a weekly workflow that fetches price data for your entire portfolio, then uses AI Summarizer to create a concise report highlighting top performers, underperformers, and risk factors.

Productivity Tips for Traders​

1. Batch Processing: Use Schedule Triggers to run multiple data fetches simultaneously, processing entire portfolios at once rather than individually.

2. Conditional Automation: Combine triggers with conditional logic to only process data when certain criteria are met, reducing unnecessary computations.

3. Template Workflows: Create reusable workflow templates for common tasks like "Daily Market Scan" or "Weekly Portfolio Review," saving setup time.

4. Progressive Disclosure: Start with simple workflows and gradually add complexity as you become comfortable with AI integrations.

5. Performance Monitoring: Use AI tools to analyze your own trading performance data, identifying patterns in your decision-making process.

Real-World Productivity Gains​

Consider Sarah, a day trader specializing in tech stocks. She used to spend 2 hours each morning manually collecting and analyzing data for 50 stocks. By implementing an AI-powered workflow:

• Schedule Trigger initiates data fetch at 6 AM
• Fetch Data with Prices pulls overnight data
• AI Data Analyzer identifies top 5 opportunities
• AI Summarizer creates a 2-page report
• Sarah receives a notification with key insights

Now, Sarah spends just 30 minutes reviewing the AI-generated analysis, leaving more time for trade execution and risk management. Her productivity has increased by 300%, and she's more consistent in her trading approach.

Overcoming Integration Challenges​

While AI integration offers tremendous benefits, successful adoption requires careful planning:

• Start Small: Begin with one or two AI tools in your workflow before expanding.
• Validate Results: Always cross-check AI outputs with your own analysis initially.
• Continuous Learning: Regularly review and refine your workflows based on performance data.
• Data Quality Focus: Ensure your data sources are reliable before relying on AI interpretations.

The Future of Trading Productivity​

As AI technology advances, the productivity gains for traders will only increase. The combination of real-time data fetching with intelligent analysis tools creates a powerful ecosystem where traders can focus on strategy and execution while automation handles the heavy lifting.

By mastering AI integration in your trading routines, you'll not only boost your productivity but also gain a competitive edge in the markets. The key is to start with simple workflows, gradually incorporate more AI tools, and always prioritize data-driven decision-making.

Remember, the most productive traders aren't those who work the hardest—they're those who work smartest, leveraging technology to amplify their skills and insights. With ApudFlow's AI-powered workflows, that level of productivity is within reach for every trader, from beginners to professionals.

In the fast-paced world of financial markets, staying ahead of economic events can make the difference between success and missed opportunities. Introducing the Browse Economic Calendar worker - your gateway to comprehensive global economic event analysis on the ApudFlow platform.

What is Browse Economic Calendar?​

The Browse Economic Calendar worker empowers you to explore and analyze global economic events with unprecedented flexibility. Whether you're a trader looking for high-impact announcements, an analyst tracking economic trends, or an investor monitoring market-moving data, this tool provides the insights you need to make informed decisions.

Key Advantages​

• Comprehensive Event Coverage: Access thousands of economic indicators from major global economies
• Smart Filtering: Multi-select currencies, countries, and event types to focus on what matters most
• Dynamic Event Discovery: Event options automatically filter based on your currency and country selections
• Intelligent Time Tracking: See exactly when events are happening with smart countdown displays
• Historical Context: Track forecast changes and previous value revisions for deeper analysis
• Workflow Integration: Seamlessly combine with other workers for automated analysis and alerts

Perfect for Multiple Use Cases​

For Traders​

• Identify high-impact events that could move markets
• Monitor forecast changes to gauge market expectations
• Set up automated alerts for upcoming announcements
• Analyze historical event impacts on price movements

For Analysts​

• Track economic indicator trends across countries
• Study forecast revisions to understand economic sentiment
• Compare actual results against expectations
• Build comprehensive economic dashboards

For Investors​

• Stay informed about major economic releases
• Monitor central bank decisions and policy changes
• Understand the economic context behind market movements
• Plan investment strategies around key data releases

How It Works in Your Workflow​

The Browse Economic Calendar worker integrates seamlessly into your ApudFlow workflows. Here's how to leverage it:

1. Build Targeted Event Lists​

Start by selecting the currencies and countries you're interested in. The worker's smart filtering will show you only relevant events, making it easy to focus on specific markets or regions.

2. Filter by Importance​

Use the impact level filter to prioritize events:

• 0+: All events for comprehensive coverage
• 1+: Medium and higher impact events
• 2+: High and very high impact events
• 3: Only the most market-moving announcements

3. Combine with Other Workers​

The real power comes when you connect Browse Economic Calendar with other workers in your workflow:

With Price Data Workers (like Fetch Data with Prices):

• Analyze how economic events impact asset prices
• Create automated trading signals based on event outcomes
• Build historical event impact studies

With AI Analyzers (like AI Data Analyzer):

• Get AI-powered insights on event significance
• Generate automated summaries of economic releases
• Classify events by potential market impact

With Notification Workers (like Telegram Notify):

• Receive instant alerts for upcoming high-impact events
• Get notified when forecasts change significantly
• Share event calendars with your team

With Data Processing Workers (like Python Code):

• Perform custom calculations on economic data
• Create statistical models of event impacts
• Generate custom reports and visualizations

Real-World Examples​

Example 1: US Economic Monitor​

Create a workflow that:

1. Browses US economic events (currency: USD)
2. Filters for high-impact events (impact: 2+)
3. Focuses on upcoming events in the next 7 days
4. Sends Telegram notifications for each event
5. Displays results on your dashboard

Example 2: Multi-Currency Analysis​

Build a comprehensive view:

1. Select multiple currencies (USD, EUR, GBP, JPY)
2. Include forecast change history
3. Sort by event date
4. Use AI Summarizer to create daily economic briefs
5. Export data for further analysis

Example 3: Central Bank Watch​

Monitor monetary policy:

1. Filter events by "Fed Rate" or "ECB Decision"
2. Track forecast changes over time
3. Combine with price data to analyze market reactions
4. Create automated reports on policy impacts

Available Integration Options​

Your Browse Economic Calendar worker can connect with many other workers on the platform, including:

• Data Connectors: Fetch Data with Prices, Twelve Data Market API, FRED Economic Data Connector
• AI Tools: AI Summarizer, AI Data Analyzer, AI Classifier, VectorAnalyzer
• Communication: Telegram Notify, Email notifications
• Data Processing: Python Code, TimescaleDB SQL, MergeData
• Storage: MongoDB, Redis for caching results
• Workflow Control: Delay, Wait for Workers, Loop for automated processing

Getting Started​

1. Add to Workflow: Drag the Browse Economic Calendar worker into your workflow canvas
2. Configure Filters: Set your currency, country, and event preferences
3. Connect Outputs: Link to other workers for automated processing
4. Set Up Dashboard: Display results in widgets for real-time monitoring
5. Test and Run: Execute your workflow to see economic events in action

Why Choose Browse Economic Calendar?​

• User-Friendly: Visual interface makes complex filtering simple
• Comprehensive: Covers all major economic indicators globally
• Flexible: Adapts to your specific analysis needs
• Integrated: Works seamlessly with your existing workflows
• Real-Time: Access to the latest economic data and forecasts
• Historical: Track changes and revisions over time

Whether you're building automated trading systems, creating economic research reports, or just staying informed about market-moving events, the Browse Economic Calendar worker provides the foundation you need for sophisticated economic analysis.

Start exploring global economic events today and gain the edge in your financial decision-making!

In the world of financial analysis and algorithmic trading, access to reliable, comprehensive price data is the foundation of successful strategies. Introducing the Fetch Data with Prices worker - your gateway to historical and real-time market data across stocks, cryptocurrencies, currencies, and commodities on the ApudFlow platform.

What is Fetch Data with Prices?​

The Fetch Data with Prices worker provides seamless access to OHLC (Open, High, Low, Close) price data and volume information for a wide range of financial instruments. Whether you're building trading algorithms, conducting technical analysis, or creating market research reports, this worker delivers the data you need in the format you want.

Key Advantages​

• Universal Market Coverage: Access data for stocks, cryptocurrencies, forex pairs, and commodities
• Flexible Time Intervals: From 1-minute intraday data to monthly aggregations
• Global Timezone Support: Convert timestamps to any major timezone for accurate analysis
• High-Performance Queries: Optimized data retrieval for fast, reliable results
• Workflow Integration: Seamlessly combine with analysis and visualization tools
• Comprehensive Data: OHLC prices plus volume data for complete market analysis

Perfect for Multiple Use Cases​

For Traders​

• Build automated trading strategies with historical data
• Backtest trading algorithms across different timeframes
• Monitor price movements in real-time for live trading decisions
• Analyze volume patterns to understand market participation

For Analysts​

• Conduct technical analysis with multiple timeframe data
• Create custom indicators and statistical models
• Study price correlations across different asset classes
• Generate comprehensive market reports and visualizations

For Developers​

• Feed price data into machine learning models
• Build custom trading bots and automated systems
• Create real-time dashboards and monitoring tools
• Develop algorithmic trading strategies

How It Works in Your Workflow​

The Fetch Data with Prices worker integrates effortlessly into your ApudFlow workflows, serving as the data foundation for your analytical processes.

1. Select Your Instruments​

Choose from thousands of available symbols using the intelligent autocomplete search. The worker supports:

• Stocks: Major exchanges worldwide (AAPL, TSLA, GOOGL, etc.)
• Cryptocurrencies: BTC, ETH, and other digital assets
• Forex: Major currency pairs (EUR/USD, GBP/USD, etc.)
• Commodities: Gold, oil, and other physical assets

2. Define Your Time Parameters​

Set precise date ranges and intervals to match your analysis needs:

• Intraday: 1m, 5m, 15m, 30m, 1h, 2h, 4h for detailed analysis
• Daily/Monthly: 1d, 5d, 7d, 1w, 1M, 3M for longer-term studies
• Custom Ranges: Any start/end date combination

3. Choose Your Timezone​

Select from major global timezones to ensure your data aligns with market hours and your local time preferences.

4. Combine with Analysis Tools​

The real power emerges when you connect Fetch Data with Prices to other workers:

With Technical Analysis Workers:

• Calculate moving averages, RSI, MACD, and other indicators
• Generate buy/sell signals based on technical patterns
• Create automated trading strategies

With AI Analyzers (like AI Data Analyzer):

• Apply machine learning to price patterns
• Predict future price movements
• Identify market anomalies and opportunities

With Visualization Workers:

• Create interactive charts and graphs
• Build real-time dashboards
• Generate performance reports

With Notification Workers (like Telegram Notify):

• Receive alerts on price movements
• Get notified of significant market events
• Share price updates with your team

Real-World Examples​

Example 1: Technical Analysis Dashboard​

Create a comprehensive analysis workflow:

1. Fetch daily price data for S&P 500 stocks
2. Calculate technical indicators (RSI, MACD, Bollinger Bands)
3. Generate buy/sell signals based on indicator combinations
4. Display results in interactive charts on your dashboard
5. Send alerts when signals trigger

Example 2: Crypto Trading Bot​

Build an automated cryptocurrency trading system:

1. Fetch 5-minute price data for BTC/USD
2. Apply momentum and trend-following algorithms
3. Execute trades based on predefined criteria
4. Track performance and generate reports
5. Adjust strategies based on backtesting results

Example 3: Multi-Asset Portfolio Analysis​

Monitor a diversified investment portfolio:

1. Fetch price data for stocks, bonds, and commodities
2. Calculate portfolio returns and risk metrics
3. Generate correlation analysis across assets
4. Create performance visualizations
5. Send weekly portfolio summaries

Available Integration Options​

Your Fetch Data with Prices worker can connect with many other platform workers, including:

• Analysis Tools: Technical Analysis Calculator, AI Data Analyzer, VectorAnalyzer
• Data Processing: Python Code, TimescaleDB SQL, MergeData
• Visualization: Chart widgets, dashboard components
• Communication: Telegram Notify, email notifications
• Storage: MongoDB, Redis for caching and persistence
• Workflow Control: Schedule Trigger, Loop for automated processing

Getting Started​

1. Add to Workflow: Drag the Fetch Data with Prices worker into your workflow canvas
2. Select Symbol: Use autocomplete to find your desired instrument
3. Set Parameters: Choose date range, interval, and timezone
4. Connect Outputs: Link to analysis or visualization workers
5. Test and Run: Execute your workflow to see price data in action

Why Choose Fetch Data with Prices?​

• Comprehensive Coverage: Access data across all major asset classes
• Flexible Configuration: Customize timeframes and parameters for any use case
• High Performance: Optimized queries ensure fast data retrieval
• Global Timezone Support: Accurate timestamp conversion for international markets
• Workflow Ready: Designed for seamless integration with analytical tools
• Production Reliable: Built for both backtesting and live trading applications

Whether you're building sophisticated trading algorithms, conducting market research, or creating financial dashboards, the Fetch Data with Prices worker provides the reliable data foundation you need for successful financial analysis.

Start accessing comprehensive market data today and elevate your financial workflows to the next level!

Are you tired of manually analyzing trading data to find patterns that work? The Ratio Rates worker in ApudFlow automates the discovery of profitable trading patterns, helping you identify which market conditions consistently lead to successful trades.

What Makes Ratio Rates Powerful?​

Ratio Rates analyzes your historical trading data to find similar patterns and calculates their success rates automatically. Instead of guessing which indicators matter most, let Ratio Rates test different combinations and show you the winning formulas.

Key Benefits:

• Automated Pattern Discovery: Tests all possible combinations of your selected indicators
• Success Rate Calculation: Shows exactly what percentage of similar trades were profitable
• Risk Assessment: Helps you understand the reliability of different market conditions
• Strategy Optimization: Identifies the most effective indicator combinations for your trading

How It Works in Your Workflow​

Ratio Rates is part of ApudFlow's visual workflow system. You can easily connect it with other workers to create powerful trading analysis pipelines.

Quick Setup Example: Market Data Analysis​

1. Fetch Historical Data: Start with a data connector like Twelve Data or Polygon.io to get market data
2. Filter Relevant Trades: Use the Sort & Filter worker to focus on specific time periods or conditions
3. Apply Ratio Rates: Analyze patterns and calculate success rates
4. Display Results: Show the findings on your dashboard with widgets

Step-by-Step Workflow Creation​

1. Access the Workflow Editor​

Go to the Workflows section in your ApudFlow dashboard. Click Create New Workflow to start building your analysis pipeline.

2. Add Data Source​

From the left panel, drag a Twelve Data or Polygon.io worker onto the canvas. Configure it to fetch historical price data for your chosen asset.

Pro Tip: Use the visual interface to select your symbol, date range, and data type - no coding required!

3. Prepare Your Trading Data​

Connect a Sort & Filter worker to clean and prepare your data. You might want to:

• Filter for specific market conditions
• Select relevant columns (price, volume, indicators)
• Focus on particular time frames

4. Add Ratio Rates Analysis​

Drag the Ratio Rates worker onto your canvas and connect it to your filtered data.

Configuration Options:

• Match Columns: Select which data columns to analyze for patterns (e.g., price change, volume, technical indicators)
• Always Include: Choose columns that must be part of every pattern analysis
• Profit Column: Specify which column contains your profit/loss data
• Similarity Threshold: Set how closely patterns must match (default 80%)

5. View and Act on Results​

The Ratio Rates worker adds new columns to your data:

• RR_BEST: Success rate of the best-performing pattern
• total_profit_best: Total profit from similar trades
• similar_trades: Number of historical matches found
• best_columns: The winning indicator combination

Real-World Use Cases​

Trading Strategy Validation​

Connect Ratio Rates to your backtesting data to see which entry signals actually work. Identify the most reliable combinations of indicators for your strategy.

Risk Management​

Before entering a trade, use Ratio Rates to check historical success rates for similar market conditions. Make informed decisions based on data, not intuition.

Pattern Discovery​

Let the algorithm find patterns you might have missed. Ratio Rates tests combinations you may not have considered, potentially uncovering new profitable setups.

Performance Optimization​

Compare different indicator sets to find the most effective combinations. Focus your analysis on what actually moves the needle.

Combine with Other Workers​

Ratio Rates works beautifully with the broader ApudFlow ecosystem:

• Data Connectors: Twelve Data, Polygon.io, FRED for economic data
• Processing: Sort & Filter, Aggregate for data preparation
• AI Integration: AI Chat for interpreting results, AI Summarizer for insights
• Storage: MongoDB, Redis for saving analysis results
• Notifications: Telegram Notify for alerts on high-probability setups

Getting Started​

1. Create a new workflow in the Workflows section
2. Add your data source (market data connector)
3. Connect Ratio Rates and configure your analysis parameters
4. Run the workflow to see pattern analysis results
5. Add to dashboard as a widget for ongoing monitoring

Advanced Tips​

• Start Simple: Begin with 2-3 key indicators to avoid analysis paralysis
• Adjust Similarity: Lower thresholds find more matches but may be less precise
• Combine Results: Use multiple Ratio Rates workers with different configurations
• Monitor Performance: Set up recurring workflows to track changing market dynamics

Ratio Rates transforms complex pattern analysis into an automated, visual process. Stop guessing and start discovering what actually works in your trading approach.

Ready to uncover your winning patterns? Try Ratio Rates in your next workflow!

Introducing the AI Classifier worker - a powerful new addition to the ApudFlow platform that brings intelligent decision-making capabilities to your workflows. Using advanced AI models, this worker can analyze complex data patterns and make classification decisions that drive your automated processes.

What is AI Classifier?​

The AI Classifier worker leverages large language models to analyze data and classify it according to your specific instructions. Unlike traditional rule-based classifiers, AI Classifier can understand context, recognize patterns, and make nuanced decisions based on natural language prompts.

Key Features​

• Flexible Classification: Define your own classification criteria and options
• Context-Aware Analysis: Processes complex data structures and understands relationships
• Multiple AI Models: Choose from various AI models for different use cases
• Workflow Integration: Seamlessly integrates with existing workflow logic
• Real-time Processing: Fast classification for time-sensitive decisions

Financial Markets Applications​

AI Classifier excels in financial data analysis and automated trading scenarios. Here are some powerful use cases:

1. Stock Market Classification​

Automatically classify stocks based on their characteristics:

Prompt: "Classify this stock data as: gold, nasdaq, crypto, forex, commodities"

Use Case: Route different types of financial instruments to specialized analysis workflows.

2. Market Sentiment Analysis​

Analyze news articles and social media sentiment:

Prompt: "Analyze the sentiment of this financial news: bullish, bearish, neutral"

Use Case: Automatically adjust trading strategies based on market sentiment.

3. Trading Signal Generation​

Generate buy/sell/hold signals from technical indicators:

Prompt: "Based on RSI, MACD, and volume indicators, generate signal: buy, sell, hold"

Use Case: Create automated trading systems that respond to technical analysis.

4. Risk Assessment​

Evaluate investment risk levels:

Prompt: "Assess risk level based on volatility, beta, and Sharpe ratio: low, medium, high, extreme"

Use Case: Implement dynamic risk management in investment portfolios.

5. Market Regime Detection​

Identify current market conditions:

Prompt: "Classify current market regime: trending_bullish, trending_bearish, ranging, volatile, calm"

Use Case: Switch between different trading strategies based on market conditions.

6. News Impact Classification​

Determine the significance of financial news:

Prompt: "Classify the impact of this news on markets: major, moderate, minor, irrelevant"

Use Case: Filter and prioritize news feeds for faster decision making.

7. Asset Allocation Recommendations​

Suggest portfolio allocations:

Prompt: "Recommend asset allocation based on risk profile: conservative, balanced, aggressive"

Use Case: Automate portfolio rebalancing based on changing market conditions.

How to Use AI Classifier​

Basic Setup​

1. Add AI Classifier to your workflow canvas
2. Configure the prompt with your classification instructions
3. Specify data source using the dataExp field
4. Connect to decision branches based on classification results

Example Workflow: Stock Analysis Pipeline​

[Data Fetcher] → [AI Classifier: "gold, nasdaq, crypto"]
                    ↓
          ┌─────────┴─────────┐
          │                  │
[Gold Analysis]    [Stock Analysis]
     ↓                     ↓
[Gold Strategies]    [Tech Strategies]

Advanced Configuration​

Prompt Engineering Tips:

• Be specific about classification criteria
• Include examples in your prompts
• Define clear decision boundaries
• Test with sample data before deployment

Data Input Options:

• Direct data objects
• Context expressions (data.price, vars.indicators)
• Complex nested structures
• Real-time market data feeds

Technical Implementation​

The AI Classifier uses OpenRouter's API to access multiple AI models including:

• Meta Llama 3.1 (recommended for financial analysis)
• GPT-4 (for complex reasoning)
• Claude (for nuanced decision making)
• Other specialized models

Response Processing:

• Automatic extraction of clean decisions
• Removal of AI explanations and reasoning
• Consistent output format for workflow integration

Performance & Reliability​

• Low Latency: Optimized for real-time decision making
• Error Handling: Graceful fallbacks and error reporting
• Cost Effective: Efficient token usage and model selection
• Scalable: Handles high-frequency trading scenarios

Real-World Success Stories​

Automated Trading Bot​

A quantitative trading firm implemented AI Classifier to automatically categorize incoming market data and route it to specialized analysis engines, reducing manual classification time by 95%.

Risk Management System​

An investment bank uses AI Classifier to assess risk levels of new positions in real-time, ensuring compliance with regulatory requirements and internal risk policies.

News-Driven Trading​

A hedge fund employs AI Classifier to analyze breaking financial news and automatically adjust portfolio positions based on sentiment and impact analysis.

Getting Started​

Ready to add intelligent decision-making to your workflows?

1. Access AI Classifier in your ApudFlow workspace
2. Start with simple classifications to understand the capabilities
3. Gradually increase complexity as you become familiar with prompt engineering
4. Integrate with existing workflows for enhanced automation

Future Enhancements​

We're continuously improving AI Classifier with:

• Custom model fine-tuning options
• Batch processing capabilities
• Advanced prompt templates
• Integration with more AI providers
• Specialized financial analysis models

Important Disclaimer: AI Classifier is a tool for automated decision-making and classification. The classifications and decisions generated by this tool should not be considered as professional financial, investment, or trading advice. All investment decisions should be made based on your own research, risk tolerance, and consultation with qualified financial professionals. Past performance does not guarantee future results. Use this tool at your own risk and responsibility.

AI Classifier represents the next evolution in workflow automation, bringing AI-powered intelligence to decision-making processes. Whether you're building trading systems, risk management platforms, or automated data processing pipelines, AI Classifier provides the intelligent routing capabilities you need.

Have questions or need help implementing AI Classifier in your workflows? Reach out to our support team!

Workflow synchronization just got a whole lot easier with our new Wait for Workers worker! This powerful addition to the ApudFlow platform allows you to coordinate parallel workflow branches and ensure operations run in the correct order.

What is Wait for Workers?​

The Wait for Workers worker monitors the execution status of other workers in your workflow and waits until all specified workers have completed their tasks. It's perfect for scenarios where you need to:

• Synchronize parallel data processing branches
• Wait for multiple API calls to complete
• Coordinate dependent operations
• Ensure data availability before proceeding

How It Works​

Auto-Detection Mode (Recommended)​

Simply connect workers to your Wait for Workers node, and it will automatically detect and monitor all connected workers. No manual configuration needed!

Manual Mode​

For advanced use cases, you can manually specify worker IDs to wait for specific workers that may not be directly connected.

Key Features​

• Automatic Detection: Intelligently detects connected workers from workflow topology
• Real-time Monitoring: Periodically checks worker status in the database
• Timeout Protection: Configurable timeout to prevent infinite waiting
• Error Handling: Optional failure on any worker error
• Parallel Coordination: Perfect for synchronizing multiple parallel branches

Configuration Parameters​

Return Values​

The worker returns a comprehensive status report:

{
  "completed": ["worker_id_1", "worker_id_2"],
  "failed": [],
  "timeout": false,
  "total_waited": 2.5,
  "auto_detected": true
}

Example Use Case​

Imagine you have a workflow that:

1. Fetches stock data from Yahoo Finance
2. Simultaneously processes the data with an LLM for analysis
3. Needs both results before generating a final report

With Wait for Workers, you can ensure the final report generation waits for both the data fetch AND the LLM analysis to complete.

Getting Started​

1. Add a "Wait for Workers" node to your workflow
2. Connect your parallel workers to the wait node
3. Configure timeout and error handling preferences
4. Connect the wait node to your downstream processing

The worker will automatically detect and wait for all connected workers to complete!

Watch the Tutorial​

For a visual guide on how to use the Wait for Workers worker, check out our tutorial video:

How to Use Wait for Workers

This new worker significantly simplifies workflow coordination and makes building complex, parallel processing pipelines much more intuitive. Try it out in your next workflow!