What is the visual flow builder?

A drag-and-drop canvas for building multi-step API tests without code. Each node is a request; edges define order; variables extracted from one response are injected into later ones. It covers the same ground as a hand-written integration script with a visible execution graph.

Can flows branch on a response?

Yes. A flow can take different paths depending on a status code or a value in the response body, which is what makes it possible to model realistic scenarios such as retrying after a 429 or following a redirect to a different resource.

Do I need to write code to use it?

No. Variable extraction, injection and assertions are configured through the interface. Teams that prefer code can still export results and wire the flow into a pipeline.

Visual Flow Builder: Drag-and-Drop API Test Workflows

What is Visual Flow Builder?

Flow Builder is a drag-and-drop interface for creating multi-step API test workflows. Instead of writing code or chaining requests manually, you:

🎨 Drag nodes onto canvas: HTTP Request, Extract Variable, Assertion, Delay
🔗 Connect nodes: Draw arrows to define execution order
💾 Extract variables: Pull user_id from response, store for later
🔄 Inject variables: Use {{user_id}} in next request body/headers
▶️ Run flow: Execute entire workflow, see results per node

Perfect for testing complex workflows that span multiple API calls.

Why Flow Builder matters

Most API testing tools require writing code for multi-step scenarios. Flow Builder solves this by:

✅ Visual workflow design: Non-developers can build complex tests
✅ No scripting needed: Everything is drag-and-drop and forms
✅ Easy debugging: Click any node to see request/response at that step
✅ Reusable flows: Save flows as templates, clone for similar tests
✅ Team collaboration: Share flows via URL, anyone can run them

Flow Builder node types

🌐

HTTP Request

Make API call (GET, POST, PUT, DELETE)

📤

Extract Variable

Pull value from response (JSON path, regex)

✔️

Assertion

Validate response (status code, body contains)

⏱️

Delay

Wait N seconds before next step

🔀

Conditional

If/else branching based on response

🔁

Loop

Repeat N times or iterate over array

🧮

Transform

Modify variable (concat, hash, encode)

📊

Log

Print variable value to console

How to build a flow in Flasqo

Example: E-commerce checkout flow

We'll build: Signup → Login → Add to cart → Apply coupon → Checkout

Step 1: Go to Testing Types → Visual Flow Builder → Launch

Step 2: Create new flow
Click "New Flow", name it "Checkout Flow"

Step 3: Add first node (Signup)
• Drag "HTTP Request" node onto canvas
• Configure:
- Method: POST
- URL: https://api.example.com/auth/signup
- Body: {"email": "test@example.com", "password": "SecurePass123"}

Step 4: Extract user ID
• Drag "Extract Variable" node onto canvas
• Connect signup node → extract node
• Configure:
- Variable name: user_id
- JSON path: $.data.user_id

Step 5: Add login node
• Drag "HTTP Request" node
• Connect extract node → login node
• Configure:
- Method: POST
- URL: https://api.example.com/auth/login
- Body: {"email": "test@example.com", "password": "SecurePass123"}

Step 6: Extract auth token
• Drag "Extract Variable" node
• Connect login node → extract node
• Configure:
- Variable name: auth_token
- JSON path: $.token

Step 7: Add to cart (using extracted token)
• Drag "HTTP Request" node
• Connect previous extract → this node
• Configure:
- Method: POST
- URL: https://api.example.com/cart/add
- Headers: Authorization: Bearer {{auth_token}}
- Body: {"product_id": "12345", "quantity": 2}

Step 8: Apply coupon
• Drag "HTTP Request" node
• Configure:
- Method: POST
- URL: https://api.example.com/cart/coupon
- Headers: Authorization: Bearer {{auth_token}}
- Body: {"code": "SAVE20"}

Step 9: Checkout
• Drag "HTTP Request" node
• Configure:
- Method: POST
- URL: https://api.example.com/checkout
- Headers: Authorization: Bearer {{auth_token}}
- Body: {"payment_method": "card"}

Step 10: Add assertion
• Drag "Assertion" node
• Connect checkout node → assertion
• Configure:
- Assert: status_code == 200
- Assert: response.body.order_id exists

Step 11: Run flow
Click "Run Flow" → Flasqo executes all nodes in order → See results per node

Variable extraction & injection

Extract from JSON response

Use JSON path syntax:


Response: {"data": {"user": {"id": 42}}}

JSON Path: $.data.user.id

Extracted: user_id = 42

Extract from headers


Response Header: Set-Cookie: session_id=abc123

Regex: session_id=([^;]+)

Extracted: session_id = "abc123"

Inject into next request


Extracted: auth_token = "xyz789"

Next Request Header: Authorization: Bearer {{auth_token}}

Actual Sent: Authorization: Bearer xyz789

Advanced features

Conditional branching

Create if/else logic based on responses:

1. POST /auth/login

2. If status == 200: → GET /dashboard

3. Else: → Assert "Login failed" appears

Loops

Iterate over arrays or repeat N times:

1. GET /products → Extract product IDs array

2. Loop over each product_id:

→ GET /products/{{product_id}}

→ Assert response contains price

Variable transformations

Modify variables before injecting:


Extracted: password = "mypass"

Transform: hash_sha256(password)

Result: hashed_password = "a665a45..."

Inject: {"password": "{{hashed_password}}"}

Real-world flow examples

User lifecycle test

1. POST /auth/signup → Extract user_id

2. GET /verify-email?token={{email_token}}

3. POST /auth/login → Extract auth_token

4. PATCH /users/{{user_id}} → Update profile

5. DELETE /users/{{user_id}} → Delete account

6. GET /users/{{user_id}} → Assert 404

Multi-service integration

1. POST api.service-a.com/create → Extract resource_id

2. POST api.service-b.com/process → Body: {"resource": "{{resource_id}}"}

3. GET api.service-a.com/status/{{resource_id}} → Assert "processed"

Performance baseline

1. Loop 100 times:

→ GET /api/search?q=test

→ Log response_time

2. Assert average(response_time) < 200ms

Best practices

1. Name your variables clearly

Use descriptive names: auth_token, not t1. Future you will thank you.

2. Add assertions between steps

Don't wait until the end to validate. Assert after each critical step:


POST /login → Assert status == 200

Extract token → Assert token exists

GET /dashboard → Assert response contains user data

3. Use delays for rate-limited APIs

If your API has rate limits, add Delay nodes between requests to avoid 429 errors.

4. Save flows as templates

Create reusable flows for common scenarios (login flow, CRUD flow). Clone and customize for new tests.

5. Test edge cases with conditional nodes

Use Conditional nodes to handle both success and failure paths in one flow.

Flow Builder vs code-based testing

Aspect	Code-Based Testing	Flow Builder
Learning curve	Requires programming knowledge	No code required
Multi-step workflows	Manual chaining with variables	Visual drag-and-drop
Debugging	Console logs, breakpoints	Click node → see request/response
Team sharing	Git repo, code review	Share URL, run instantly
Non-technical users	Cannot create tests	Can build complex flows

When to use Flow Builder

Use Flow Builder when:

Testing multi-step user journeys (signup → onboarding → first action)
You need to pass data between requests (extract ID, use in next call)
Non-developers need to create tests
You want visual documentation of test workflows
Debugging complex request chains

Use code/scripts when:

Complex data transformations (custom hashing, encryption)
Integration with CI/CD pipelines (prefer API/CLI)
Advanced logic (nested loops, recursion)
Custom assertions beyond status codes/body checks

Build complex API flows visually

Drag nodes, connect steps, extract variables. No code required for advanced multi-step testing.

Try Flow Builder Free

Visual Flow Builder: Drag-and-drop multi-step API testing