Cloud Platform Reference

SolStudio Cloud is the workflow automation platform. Instead of generating Rust, Cloud runs connected workflow nodes: triggers start executions, actions call Solana-aware services, logic routes items, and outputs send results to another system.

Want practice instead of reference reading? Open the Cloud Learning Path and build the price monitor, swap guard, and manual payout exercises.

Mental Model

A Cloud workflow is a directed graph of nodes. Each node receives workflow items, reads configured properties, emits new workflow items, and records execution logs.

Cloud is for automation. Use the visual builder when you need generated Solana program code. Use Cloud when you need cron jobs, webhook intake, AI decisions, token transfers, swaps, or external notifications.

Node Families

Node Credential Matrix

Connection Rules

Cloud connections carry typed data between node handles.

Port types:

Important rules:

• Trigger nodes are source nodes. They do not receive normal inputs.
• Output nodes finish a branch. They should not have outgoing connections.
• Most workflow paths should read left to right: trigger, data/action, AI or logic, risky action, output.
• Wallet actions should usually sit behind an explicit If / Else when the decision depends on AI or external data.

Workflow Item Data

Nodes pass arrays of items. Each item has a JSON object:

{
  "json": {
    "token": "SOL",
    "price": 142.12,
    "alert": true
  }
}

Most action nodes merge their result into the incoming item. For example, Fetch Price can receive { "token": "SOL" } and emit the same item with price and priceData attached.

Execution Visibility

The Cloud editor keeps a bottom execution rail visible. Open it to inspect runs, preflight checks, logs, and node JSON output.

During a run, nodes and connected edges update on the canvas so the active step is visible while data moves through the workflow.

Preflight checks the saved graph, route, credentials, wallet actions, fee estimate, warnings, and blockers. It does not call provider APIs, sign transactions, or send webhooks. Run performs preflight first, then queues and executes the workflow if it is not blocked.

Expressions

Expression fields can reference data from the current item.

Use expressions when a value should come from an earlier node instead of being hard-coded in the properties panel.

Trigger Nodes

Manual Trigger

Manual Trigger has no required properties and no inputs. It starts when the user clicks Run.

Use it for first tests, one-off operations, and workflows that should not run automatically.

Cron Trigger

Cron Trigger starts a workflow on a recurring schedule.

Use Cron Trigger for monitoring and reporting. Keep the schedule conservative until you have reviewed execution logs.

Webhook Trigger

Webhook Trigger starts a workflow from an HTTP request.

Use Webhook Trigger when another product, bot, backend, or alerting system should start the run.

Action Nodes

Fetch Price

Fetch Price gets token price data from Birdeye or DexScreener.

Use it before AI, If / Else, alerts, and swap guards.

Example connection:

Cron Trigger -> Fetch Price -> If / Else -> Run Log

Token Transfer

Token Transfer sends SOL or SPL tokens from a selected Cloud wallet.

Use it only after confirming:

• The destination address is correct.
• The amount is in the expected unit.
• The selected wallet is the intended signing wallet.
• A manual test run produced the expected signature output.

Example connection:

Manual Trigger -> Token Transfer -> Workflow Result

Jupiter Nodes

Jupiter features are split into separate nodes so each workflow step only shows the settings it needs.

Use swap operations behind a guard step when the swap depends on external data:

Webhook Trigger -> Fetch Price -> AI Agent -> If / Else -> Jupiter Direct Swap -> Workflow Result

slippageBps is basis points. 50 means 0.5%. Leaving advanced order fields blank keeps more routers eligible. Receiver, referral, payer, and router-exclusion fields can change routing behavior.

For most first tests, choose Jupiter Price. It does not need a wallet and can run with keyless Jupiter access. For production rate limits, add a Jupiter credential or configure JUPITER_API_KEY on the server.

Oracle Price

Oracle Price reads Pyth Hermes directly, searches Pyth feed IDs, or calls a Switchboard-compatible HTTP endpoint when you provide an API URL and credential.

Pyth output includes normalized price, raw price, confidence, exponent, publish time, and the fetch timestamp. Use Pyth Latest Prices when a workflow needs multiple feed IDs in one call.

Helius RPC

Helius nodes are split by task. Helius Wallet Activity reads recent signatures through JSON-RPC, Helius Transaction reads raw JSON-RPC transaction details, Helius Parse Transaction uses Enhanced Transactions to turn one signature into readable transfer/swap/NFT data, and Helius Address Transactions fetches enhanced history for an address with type, source, token-account, sorting, and pagination filters.

Helius RPC is the low-level escape hatch for DAS and Solana JSON-RPC calls. It supports the standard DAS methods getAsset, getAssetBatch, getAssetProof, getAssetProofBatch, getAssetsByAuthority, getAssetsByCreator, getAssetsByGroup, getAssetsByOwner, getNftEditions, getSignaturesForAsset, getTokenAccounts, and searchAssets, plus Solana RPC methods such as getSignaturesForAddress and getTransaction.

Use Params JSON as the exact JSON-RPC params array. For DAS calls, add a Helius credential or a DAS-compatible RPC URL.

Helius Webhooks

Helius webhook nodes turn realtime Solana activity into a Cloud trigger source.

Use Webhook Trigger first to create a Cloud webhook URL, then point Helius Webhook Create at that URL. For production, configure authHeader so Helius sends a secret your workflow can check.

Metaplex Asset

Metaplex Asset is the guided DAS node for NFT, compressed NFT, and token metadata reads.

This node requires a Helius credential unless you provide another DAS-compatible RPC URL.

Squads Proposal

Squads Proposal sends a prepared approval payload to your own Squads-compatible API or webhook adapter. Squads v4 itself is SDK/program driven, so this node does not claim to directly create on-chain proposals without an adapter service. Use it to hand off treasury workflow output, transaction summaries, or token-account snapshots into an approval backend.

Umbra Privacy

Umbra nodes are split into service checks and transfer planning:

The transfer node intentionally prepares a plan instead of pretending the server completed a private transfer. Umbra execution requires a wallet signer, @umbra-privacy/web-zk-prover, the UTXO indexer, and the relayer. Use the plan in the Output tab to verify recipient, mint, amount in base units, network, and endpoint selection before wiring final wallet execution.

Example starter:

Manual Trigger -> Umbra Relayer Info -> Umbra Transfer Plan -> Workflow Result

Solana RPC Providers

Solana RPC calls standard JSON-RPC methods through public RPC, RPCFast, Helius, QuickNode, Alchemy, Triton, or a custom HTTPS endpoint.

Paste the full HTTPS endpoint into the node or save it as a provider credential. If the endpoint needs the key inserted, use {apiKey} in the URL and store the key in the credential.

Example:

Manual Trigger -> Solana RPC -> Display Output

Jito Bundles

Jito nodes are for priority transaction flow around already-signed transactions.

Jito Send Bundle does not sign transactions. Build and review the signed transaction bundle first, include a real Jito tip, then use Jito Bundle Status to confirm landing.

Notifications

Notification nodes are split by destination so non-developers do not have to shape raw HTTP payloads.

Use Display Output or Workflow Result before a notification node when you want the exact payload visible in the run output before it leaves Cloud.

Custom API Request

Custom API Request is the user-defined node escape hatch. Use it when a workflow needs a provider that SolStudio does not have a dedicated node for yet.

It can call any HTTPS endpoint, merge a webhook credential into request headers, send a body from {{ $json }}, and store the response under a custom output field so later nodes can branch or display it.

AI Agent

AI Agent calls an LLM to process workflow data.

Prefer JSON output when the next node is If / Else. For example:

Return { "approved": boolean, "reason": string }

Then branch on approved.

Logic And Transform Nodes

Use If / Else when the false path still matters. Use Filter when non-matching items should stop silently.

Wait is abort-aware and capped so it cannot hold a worker forever. Use Cron Trigger for long scheduling gaps instead of a very long Wait node.

Common operators:

Output Nodes

Use display-only output nodes when you want the result inside SolStudio, and HTTP Request only when another system must receive the payload.

HTTP Request sends data to another system. Keep first test workflows on Display Output, Run Log, or Workflow Result, then add HTTP Request only when an external service must receive the payload.

Example body:

{{ $json.signature }}

Example full-item body:

{{ $json }}

For a no-side-effect starter workflow, use:

Manual Trigger -> Jupiter Price -> Workflow Result

Wallets And Credentials

Cloud workflows can use encrypted wallets and credentials for automated actions.

Operational rules:

• Use a dedicated wallet per automation class.
• Keep wallet balances limited to what the workflow needs.
• Put AI or webhook approvals behind explicit branch nodes before wallet actions.
• Review execution logs after every activation.

Common Workflow Patterns

Cloud Versus Other Surfaces

Activation Checklist

• The workflow has exactly one trigger path you understand.
• Every wallet action uses the intended wallet.
• AI output is structured when logic needs to branch on it.
• Every risky action sits after an explicit guard step.
• Webhook URLs, headers, and credentials are configured.
• A manual test run produced the expected execution log.
• The final output node reports enough data to debug failed runs.

Common Fixes