Flows

Using fetch-url and api-call steps

Both the fetch-url and api-call steps make HTTP requests to external services, and both support every HTTP method, custom headers, and a request body. The difference is what each adds on top: Fetch URL can also scrape pages with Firecrawl or Massive and handle markdown/response-type conversion, while Make API Call adds request templating, response mapping, and an auth helper.

Each step’s configuration is a fill-in-the-blank panel that saves as you edit; there is no separate Save Step button. Rename a step inline in its header, and set the variable its result is stored under in the step’s Output variable field (the small variable control on the step card, placeholder output_data).

Fetch URL step

Add a fetch-url step

  1. In the Flow editor, click Add Step
  2. Select Fetch URL
  3. Choose a mode at the top of the step: Standard HTTP, Firecrawl (Web Scraping), or Massive (Web Render)

Standard HTTP mode

Configure:

  • URL — the endpoint to call (accepts {{variable}} mentions)
  • Method — GET, POST, PUT, DELETE, or PATCH (defaults to GET)
  • Body — the request payload, shown only for POST, PUT, and PATCH. Switching back to GET or DELETE hides the body field without clearing its stored value.
  • Response type — JSON, Text/HTML, or XML. With Text/HTML you can also turn on Prefer Markdown when available to get cleaned markdown.
  • Headers — key-value pairs under the step’s advanced settings
https://api.example.com/products/{{productId}}

Firecrawl (web scraping) mode

Switch the mode to Firecrawl (Web Scraping) to scrape a page instead of making a plain HTTP request. Firecrawl handles JavaScript rendering and returns clean content. You can configure:

  • Formats — one or more of markdown, html, rawHtml, screenshot, links, json
  • Extract main content only — strip navigation and boilerplate
  • JSON extraction — provide a JSON schema or describe what to extract, and Firecrawl returns structured data
  • Advanced options such as cache freshness (maxAge), country, and languages

Massive (web render) mode

Switch the mode to Massive (Web Render) to fetch hard-to-retrieve pages through the Massive Web Render API. Massive renders JavaScript, solves captchas, and retries through a residential network, which helps with sites that block or challenge datacenter traffic. You can configure:

  • Output format — markdown (default), rendered HTML, or raw HTML
  • Country — two-letter ISO code to fetch from a specific country (for example us)
  • Delay — 0.1 to 10 supplemental seconds before capturing content on slow-loading pages
  • Cache expiration — days before cached content is considered stale (0 disables caching)

Make API Call step

Use Make API Call when you want request templating, response mapping, or the built-in auth helper.

Add an api-call step

  1. Click Add Step
  2. Select Make API Call
  3. Configure:
    • Method — GET, POST, PUT, DELETE, or PATCH
    • URL — the endpoint URL
    • Body — request body, shown for POST, PUT, and PATCH
    • Response type — JSON, Text, or XML
    • Headers — key-value pairs under advanced settings

Setting headers

Add headers as key-value pairs in either step’s headers section:

Content-Type: application/json
Authorization: Bearer {{secret:API_KEY}}
X-Custom-Header: {{customValue}}

Request body

For POST/PUT/PATCH requests, provide the body (JSON is typical):

1{
2  "customer": "{{customerName}}",
3  "order": {
4    "items": "{{order_items}}",
5    "total": "{{calculate_total}}"
6  }
7}

Authentication

Bearer token

Authorization: Bearer {{secret:API_KEY}}

Basic auth

Encode username:password in base64:

Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

API key in header

X-API-Key: {{secret:API_KEY}}

Do not hardcode API keys in Flows. Store credentials with secrets and reference them with {{secret:SECRET_NAME}} syntax.

Handling responses

The response is stored under the step’s Output variable name. Reference it in later steps:

{{api_response}}                // Full response body
{{api_response.data}}           // Nested property

Error handling

API calls can fail. Configure error handling on the step itself (continue on error, stop on error, or use fallbacks), or use a Conditional Logic step to check the result before proceeding.

Dynamic URLs

Build URLs from variables:

https://api.example.com/{{resource}}/{{itemId}}?filter={{searchTerm}}

Rate limiting

Some APIs rate-limit requests. Add a Wait Until step between calls if needed:

  1. API call step
  2. Wait Until step with delayMs (e.g., 1000 for a 1-second pause)
  3. Next API call

Testing a step

You can test a single HTTP step without re-running the whole Flow, but only after the Flow has run at least once (the test re-uses the variables captured in the most recent run):

  1. Run the Flow once
  2. Open the step’s action menu (the ⋯ button on the step card)
  3. Choose Test with last run
  4. Review the request and response in the test panel

Best practices

  • Validate responses: Check status codes before using response data
  • Handle errors gracefully: Use conditionals for retry logic or fallbacks
  • Keep secrets secret: Reference credentials with {{secret:NAME}}, never hardcode them
  • Use Firecrawl or Massive for pages, HTTP for APIs: Firecrawl and Massive modes are for fetching rendered web pages (Massive is strongest on sites that block datacenter traffic); standard HTTP is for JSON/REST endpoints

Next steps