k6 Studio

Desktop application for recording and generating k6 test scripts

k6 Studio

k6 Studio is a desktop application that helps you quickly generate k6 test scripts using a visual interface. It’s designed to accelerate test creation by recording browser interactions and converting them into k6 code.

Key features

Browser recording

Record user flows from browser interactions and generate HAR files.

Test generation

Convert HAR files into customized k6 test scripts.

Script customization

Use rules to quickly iterate on script creation and refinement.

Visual debugging

Test and debug k6 scripts with request/response inspection.

Getting started

1. Download k6 Studio

   Download the latest version for your operating system:

   • macOS
   • Windows
   • Linux
2. Install and launch

   Install k6 Studio and launch the application.

3. Start recording

   Click Record and configure your browser proxy to capture traffic.

4. Generate your test

   Stop recording and generate a k6 script from the captured HAR file.

Recording user flows

k6 Studio records browser traffic through a proxy to capture all HTTP requests and responses.

Recording workflow

1. Configure proxy

   k6 Studio automatically configures your system proxy settings when you start recording.

2. Perform user actions

   Navigate your application in the browser, performing the actions you want to test.

3. Stop recording

   Click Stop in k6 Studio to end the recording session.

4. Review captured traffic

   Review all captured requests and responses in the Studio interface.

What gets recorded

k6 Studio captures:

• HTTP/HTTPS requests and responses
• Request headers and bodies
• Response headers and bodies
• Timing information
• Cookies and authentication

Generating test scripts

After recording, k6 Studio helps you convert the HAR file into a k6 test script:

Customization options

Filtering

Remove unwanted requests:

• Static assets (images, CSS, JS)
• Third-party domains
• Specific URLs or patterns

Correlation

Automatically detect and correlate dynamic values:

• Session tokens
• CSRF tokens
• Dynamic IDs
• Timestamps

Parameterization

Replace hardcoded values with variables:

• User credentials
• API keys
• Test data
• URLs and endpoints

Think time

Add realistic delays between requests:

• Fixed sleep times
• Random delays
• Based on recorded timing

Rules for script generation

k6 Studio uses rules to transform HAR files:

// Example: Filter out static assets
{
  "type": "filter",
  "pattern": "\\.(css|js|png|jpg|gif)$",
  "action": "exclude"
}

// Example: Correlate session tokens
{
  "type": "correlate",
  "extract": "sessionToken",
  "from": "response.body",
  "pattern": "token=([^&]+)"
}

Visual debugging

k6 Studio provides a visual interface for testing and debugging scripts:

Request inspection

View detailed information for each request in your script.

Response analysis

Inspect response headers, bodies, and status codes.

Variable tracking

See how variables change throughout test execution.

Error detection

Identify and fix issues before running full tests.

Example workflow

Here’s a typical workflow using k6 Studio:

1. Record login flow

   Start recording and perform a login sequence in your application.

2. Generate initial script

   Stop recording and generate a k6 script with default settings.

3. Customize with rules

   Add rules to:

   • Extract the session token from the login response
   • Parameterize the username and password
   • Filter out static assets
4. Test the script

   Run the script in k6 Studio to verify it works correctly.

5. Export and enhance

   Export the script and add:

   • Custom thresholds
   • Multiple virtual users
   • Load ramping configuration
6. Run in k6

   Execute the final script with the k6 CLI or in Grafana Cloud k6.

Common use cases

API testing

Record API calls from your application and convert them into load tests:

1. Use your application normally
2. k6 Studio captures all API requests
3. Generate a test focusing only on API endpoints
4. Add multiple VUs to simulate load

Authentication flows

Capture complex authentication sequences:

1. Record login process
2. Extract authentication tokens
3. Parameterize credentials
4. Reuse tokens in subsequent requests

Multi-step transactions

Test complete user journeys:

1. Record checkout process
2. Correlate order IDs and session data
3. Add checks for successful completion
4. Scale to multiple concurrent users

Quick prototyping

Rapidly create test scripts:

1. Record a user flow
2. Generate a basic script
3. Use as a starting point for customization
4. Iterate quickly with rules

Best practices

Record the minimal user flow you want to test, then use k6 code to add variations and load patterns.

Clean recordings

• Close unnecessary browser tabs
• Disable browser extensions that make background requests
• Focus on the specific flow you want to test

Iterative refinement

• Start with a simple recording
• Generate a basic script
• Gradually add rules and customizations
• Test after each change

Manual enhancement

k6 Studio generates a starting point. Enhance scripts manually to:

• Add realistic think time
• Implement complex logic
• Add custom metrics
• Configure advanced scenarios

Version control

• Save rules and configurations
• Track script changes in git
• Document customizations

Limitations

k6 Studio records HTTP traffic only. WebSocket, gRPC, and other protocols require manual scripting.

• Limited to HTTP/HTTPS protocols
• Cannot capture client-side JavaScript execution
• Binary protocols need manual implementation
• Some dynamic content may require custom correlation logic

Documentation

For detailed k6 Studio documentation:

grafana.com/docs/k6-studio

Related resources

HTTP requests

Making HTTP requests with k6

Correlation

Extracting and using dynamic data

API testing

Load testing REST APIs

Grafana Cloud k6

Cloud-based test execution