Breadcrumbs

HTTP(S) Protocol

Overview

Leapwork GO supports the HTTP(S) protocol during recording and execution (preview run and timeline run). HTTP(S) is the core protocol for capturing, replaying, and performance-testing standard request-response communication between a client and a server.

Leapwork GO models each HTTP(S) network request as an individual step in a sequence. Each step represents a single request-response pair and contains the full details of the communication, including:

  • Request and response payloads

  • Headers and parameters

  • Timing metrics and status codes

HTTP(S) steps support the following methods:

Method

Description

GET

Retrieves a resource

POST

Creates a resource or submits data

PUT

Updates an existing resource

DELETE

Removes a resource

HTTP Step

The HTTP step represents a single HTTP(S) request-response operation. The step executes the request and captures the response returned by the server.

Inspector panel properties

Property

Description

Shown text

Display label for the step in the sequence (for example, GET /api/products?page=1&pageSize=12&sortBy=price&descending=false)

Display method

Checkbox to show or hide the method prefix in the step label

Method and url

The HTTP method (GET, POST, PUT, or DELETE) and the endpoint URL

Continue if fails

Checkbox to allow the sequence to continue if this step fails

Protocol

Set to HTTP

The HTTP step also contains expandable Recorded request and Recorded response sections.

Recorded request

The Recorded request section displays the request details as captured during recording. The request body supports the following body types:

Body type

Description

None

No request body

Raw

Raw body content (for example, JSON)

x-www-form-urlencoded

Form-encoded key-value pairs

Multipart Form Data

Multipart form data including file uploads

Recorded response

The Recorded response section displays the full response details returned by the server during recording, including the status code, headers, and response body.

Recording HTTP(S) Traffic

HTTP(S) steps are captured using the record functionality on a sequence. Leapwork GO uses a proxy to intercept and record network traffic between the browser and the target server.

How recording works

The recording process uses a Man-in-the-Middle (MITM) proxy:

  1. The user's browser routes traffic through the Leapwork GO recorder proxy.

  2. For HTTPS traffic, the proxy uses a trusted Certificate Authority (CA) certificate to decrypt and read the encrypted communication.

  3. Each request-response pair is captured and converted into an HTTP step in the sequence.

  4. Captured steps are streamed directly into the sequence in real time while recording is active.

Note: Today, 99% of all internet traffic is HTTPS, encrypted with SSL/TLS. The MITM process decrypts this traffic for recording. Non-SSL/TLS traffic is read in plaintext without the MITM process.

Prerequisites

Before recording HTTP(S) traffic:

  • Install the Leapwork GO CA certificate on your computer.

  • Trust the certificate in the appropriate certificate store:

    • Windows: Add to the Trusted Root Certification Authorities store.

    • macOS: Add to the System Keychain.

  • Configure a proxy extension in your browser (MS Edge or Google Chrome) with the Leapwork GO proxy address.

  • In the proxy extension settings, configure: Server address, Proxy protocol, Port, and Access token (from your profile section in Leapwork GO).

Record an HTTP(S) sequence

  1. Open your browser and navigate to the application you want to test.

  2. In Go, click Record.

  3. Choose the hostname you want to capture:

    • All URLs, or

    • Hostname-only (recommended for cleaner recordings).

  4. Click Start recording.

  5. Interact with your application (for example, refresh a page or submit a form).

  6. Click Stop when finished to stop the recording.

Go automatically lists each network request as a step. You can expand any step to view details such as:

  • Request and response payloads

  • Headers and parameters

  • Timing metrics and status codes

Note: Recorded traffic appears in the sequence while recording is still active. Steps are appended in order during the session. During streaming, the latest top-level group auto-expands and the others collapse.

Manually Adding an HTTP Call

If you already have API requests defined, you can add HTTP steps directly without recording.

Add a manual HTTP step

  1. Right-click on an empty space inside a sequence.

  2. Click add HTTP call.

  3. Configure the following properties:

    • Method — choose between GET, POST, PUT, and DELETE.

    • URL

    • Expected request:

      • Parameters

      • Headers

      • Host

      • Cookies

    • Expected response:

      • Status code

      • Cookies

Importing cURL Commands

You can import API requests defined as cURL commands directly into a sequence.

Paste a cURL command as an HTTP step

  1. Right-click on an empty space inside a sequence.

  2. Click Paste cURL as HTTP step.

  3. Paste a bash or CMD cURL command.

Go automatically converts the cURL command into a structured HTTP step that can be edited, parameterized, and reused.

Importing HTTP Requests from Files

You can also create a new HTTP sequence by importing requests from supported files. Although these options create a new sequence rather than adding steps to the currently open sequence, they are another way to get HTTP steps into Leapwork GO.

Supported import formats include:

  • JMeter test plans (.jmx)

  • HTTP Archive files (.har)

  • Postman collections (.json)

During import, Go converts the requests in the file into HTTP steps in the newly created sequence, where they can be reviewed, edited, parameterized, and reused.

Previewing Your Recording

After recording or configuring HTTP steps, you can validate the sequence using preview run.

Run a preview

  1. Click Preview to execute the sequence.

Go will:

  • Run each recorded step.

  • Display real-time execution progress with green indicators for success.

  • Show per-step response times and results.

Once validated, rename your sequence for easy reference.

Executing HTTP Steps

HTTP steps are supported in both preview run and timeline run execution modes.

During execution, the HTTP steps replicate the exact request-response communication as it was captured or otherwise defined in the sequence, allowing you to evaluate the performance of your backend in response to HTTP(S) traffic.

Full HTTP response capture

Leapwork GO captures complete, non-truncated HTTP response bodies. This is critical for enterprise applications where large responses contain dynamic session-based values (for example, control IDs) that must be accurately extracted and correlated for reliable execution.

HTTP traffic capture during timeline runs

During timeline run execution, HTTP traffic can be captured and made available in a Captures tab in run results, where you can inspect, search, filter, and export captured samples.

Child Sequence HTTP Steps

When a sequence contains a child sequence with HTTP steps, you can click those child HTTP steps and inspect their recorded request and response details in the inspector panel, the same as for top-level HTTP steps.

  • Child-sequence HTTP steps are inspectable from the parent sequence view.

  • Editing child HTTP steps should be performed in the child sequence itself.

Filtering HTTP Steps in Run Results

In the Run Results view, a filter is available to show HTTP requests only, allowing you to focus on HTTP request performance metrics.

  • A HTTP filter toggle is available in the Overall Snapshot Metrics section under the Detailed View filter.

  • When enabled, only HTTP-related data is displayed.

  • When disabled, all requests (HTTP and non-HTTP) are shown.