Migrate from Gelato Web3 Functions to Chainlink CRE

This page provides a concise mapping of Gelato Web3 Functions concepts to their CRE equivalents.

CRE runs your code across a Decentralized Oracle Network (DON) — a group of independent nodes that each execute your workflow and reach consensus on the result.

Unlike a single-executor model, every operation — API calls, blockchain reads, onchain writes — is cryptographically verified by multiple nodes, giving your workflows institutional-grade security and reliability with no single point of failure.

If any term below is unfamiliar, see the Key Terms glossary.

Terminology

The core concepts map closely between platforms, but the names differ:

Configuration

Gelato uses a combination of the Gelato UI, SDK, and IPFS for task creation and deployment. Configuration is split between schema.json (for userArgs), the UI (for triggers and secrets), and your function code.

CRE consolidates everything into files within your code repository:

All deployment and management is done through the CRE CLI (cre workflow simulate, cre workflow deploy, etc.), not a separate UI or IPFS.

Triggers

Time-based

Gelato: Time intervals (e.g., "every 5 minutes") or cron expressions, configured through the UI or SDK.

CRE: Standard cron expressions (5 or 6 fields) configured directly in your code. Supports timezone prefixes (e.g., TZ=America/New_York 0 9 * * 1-5). Minimum interval is 30 seconds.

// CRE cron trigger
const cron = new CronCapability()
handler(cron.trigger({ schedule: "0 */5 * * * *" }), onCronTrigger)

See the Cron Trigger guide for full details.

HTTP triggers

Gelato: Not natively supported as a trigger type.

CRE: Start a workflow execution in response to an external HTTP request. Supports authentication and passes the request body to your callback.

See the HTTP Trigger guide for details.

Onchain events

Gelato: Event-based triggers that watch for smart contract events, configured in the UI.

CRE: EVMClient.logTrigger() watches for specific contract events. You specify contract addresses and optionally filter by event topics, directly in your workflow code.

See the EVM Log Trigger guide for details.

Per-block triggers

Gelato: Native "every block" trigger type.

CRE: No direct equivalent. Use a short cron interval (e.g., every 30 seconds) or an EVM log trigger to achieve similar behavior.

Task authoring and output

Language and runtime

Gelato: TypeScript running in a Deno-like Node.js environment. Full access to fetch(), npm packages, and ethers.js.

CRE: TypeScript compiled to WASM via QuickJS, not Node.js. Some npm packages that depend on Node.js APIs won't work. The SDK provides built-in clients for all common operations.

HTTP / API calls

Gelato: fetch() or axios, running on a single executor.

CRE: HTTPClient.sendRequest() — each DON node fetches independently, and results are aggregated via consensus. Your API data is validated across multiple nodes before your workflow uses it.

CRE also offers a Confidential HTTP capability for privacy-preserving API calls — secrets are injected inside a secure enclave and responses can be optionally encrypted.

Onchain reads

Gelato: multiChainProvider.default() with ethers.js.

CRE: EVMClient.callContract() with viem for ABI encoding/decoding. A single workflow can read from and write to multiple chains — no need for separate infrastructure per chain.

See the Onchain Read guide for details.

Onchain writes

Gelato: Return { canExec: true, callData: [...] } from your function. Gelato relays the transaction.

CRE: Two-step process with consensus verification:

1. Generate a signed report with runtime.report()
2. Submit it onchain with EVMClient.writeReport()

// 1. Encode and generate a signed report
const report = runtime
  .report({
    encodedPayload: hexToBase64(callData),
    encoderName: "evm",
    signingAlgo: "ecdsa",
    hashingAlgo: "keccak256",
  })
  .result()

// 2. Submit the report onchain
const writeResult = evmClient
  .writeReport(runtime, {
    receiver: contractAddress,
    report,
  })
  .result()

The KeystoneForwarder contract verifies the DON's signatures before calling your consumer contract. This is the biggest architectural difference — CRE writes are cryptographically verified by the decentralized network, not relayed by a single executor.

See the Onchain Write guide and Building Consumer Contracts.

Secrets

Gelato: context.secrets.get("KEY"), configured in the UI.

CRE: Declare secrets in secrets.yaml, provide values via .env (simulation) or Vault DON (deployed), access via runtime.getSecret({ id: "KEY" }) in your code. The API is the same regardless of environment.

See the Secrets guide for details.

Monitoring

Gelato: Task dashboard in the Gelato UI showing execution history, logs, and status.

CRE: The CRE UI provides:

• Workflow status and lifecycle management (active, paused, etc.)
• Detailed execution logs and events
• Performance metrics and debugging tools

See the Monitoring & Debugging guide for details.

Deployment and lifecycle

Pricing

CRE is currently in Early Access. For pricing details, reach out via the in-app support on the CRE platform at cre.chain.link.

Get started

You can have a working CRE workflow running locally in minutes:

1. Start the Getting Started tutorial — build your first workflow from scratch, step by step
2. Create your CRE account — Account setup guide
3. Install the CRE CLI
4. Run a demo — see a complete workflow in action with a single command
5. Browse the templates — see complete workflow examples you can clone and customize