NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Go modules, #2398 by repository stars
Latest stable
v1.0.1
Last release 1 months ago
14 Oct 2026
Ships on a steady schedule
a new release about every 8 days
Nearly every release is documented
notes for 50 of 50 stable releases
Nothing withdrawn
no release was ever pulled
1 years old
670 releases · first in 2025
Drag across the ruler to compare, or tap a release to open it.
Nothing published for this version
Nothing published for this version
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v1.0.0-alpha -->
RuntimeStoreProvider by @thiva-k in https://github.com/thunder-id/thunderid/pull/4041/identity-provider and /notification-senders/message CRUD APIs in favour of /connections by @JayaShakthi97 in https://github.com/thunder-id/thunderid/pull/4019/connections API by @JayaShakthi97 in https://github.com/thunder-id/thunderid/pull/3964Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.48.0...v1.0.0-alpha
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.48.0 -->
CSS Classes via flows by @brionmario in https://github.com/thunder-id/thunderid/pull/3859Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.47.0...v0.48.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.47.0 -->
/integrate commands to ThunderID CLI by @brionmario in https://github.com/thunder-id/thunderid/pull/3625Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.46.0...v0.47.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.46.0 -->
Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.45.0...v0.46.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.45.0 -->
Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.44.0...v0.45.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
Remove deprecated logging methods and finalize the context-first logging methods by @UdeshAthukorala in https://github.com/thunder-id/thunderid/pull/3…
<img src="https://thunderid.dev/assets/images/readme/repo-banner.png" alt="ThunderID" width="100%" />
ThunderID is a lightweight, open-source Identity and Access Management (IAM) engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.44.0 -->
Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.43.0...v0.44.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
Nothing published for this version
Upgrade npm dependencies to fix security vulnerabilities by @Malith-19 in https://github.com/thunder-id/thunderid/pull/3164
<img src="https://thunderid.dev/assets/images/readme/repo-banner.png" alt="ThunderID" width="100%" />
ThunderID is a lightweight, open-source Identity and Access Management (IAM) engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.43.0 -->
Custom application template by @brionmario in https://github.com/thunder-id/thunderid/pull/3184Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.42.0...v0.43.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.42.0 -->
Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.41.0...v0.42.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows. It works across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.41.0 -->
ThunderID agentic skills & plugins to Hero & Docs by @brionmario in https://github.com/thunder-id/thunderid/pull/2950Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.40.0...v0.41.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Get started by exploring how ThunderID can be used to secure:
To learn more about overall requirements, solution patterns of these scenarios, refer to the Use Cases section.
Visit Get ThunderID to learn more about installation methods.
<!-- Release notes generated using configuration in .github/release.yml at v0.40.0 -->
ExpressJS integration to ThunderID by @JayaShakthi97 in https://github.com/thunder-id/thunderid/pull/2829Vanilla JS integration to ThunderID by @DonOmalVindula in https://github.com/thunder-id/thunderid/pull/2837npx) by @brionmario in https://github.com/thunder-id/thunderid/pull/2903Vue, Nuxt & Node.js integrations to ThunderID by @brionmario in https://github.com/thunder-id/thunderid/pull/2899@thunderid/express SDK + Update invalid refs in SDK by @brionmario in https://github.com/thunder-id/thunderid/pull/2788Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.39.0...v0.40.0
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
<!-- Release notes generated using configuration in .github/release.yml at v0.38.0 -->
types instead of schemas in user-types list API by @thiva-k in https://github.com/thunder-id/thunderid/pull/2622@asgardeo/react sdk version by @ThaminduDilshan in https://github.com/thunder-id/thunderid/pull/2714Full Changelog: https://github.com/thunder-id/thunderid/compare/v0.37.0...v0.38.0
This Quickstart guide will help you get started with ThunderID quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run ThunderID either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.38.0 release of ThunderID and run it locally.
Download the distribution from the 0.38.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunderid-0.38.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunderid-0.38.0-macos-x64.zip |
| Linux | x64 | thunderid-0.38.0-linux-x64.zip |
| Linux | ARM64 | thunderid-0.38.0-linux-arm64.zip |
| Windows | x64 | thunderid-0.38.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunderid-0.38.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunderid-0.38.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run ThunderID using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/thunder-id/thunderid/v0.38.0/install/quick-start/docker-compose.yml
Start ThunderID
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the ThunderID Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
ThunderID provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.38.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.38.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.38.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.38.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.38.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.38.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.38.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.38.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.38.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.38.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.38.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.38.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.38.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.38.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of ThunderID, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
executionId value from the response.{"executionId":"<execution_id>","flowStatus":"INCOMPLETE", ...}
<execution_id> with the executionId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"executionId":"<execution_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"executionId":"<execution_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
Nothing published for this version
   engine built to secure access for humans, AI agents, and machines.
Designed for the agentic era, ThunderID provides a developer-first IAM platform and supporting tools for securing applications, APIs, services, and agent-driven workflows across traditional and decentralized identity ecosystems, with post-quantum-ready security built in from the start.
Core design goals of ThunderID include:
<!-- Release notes generated using configuration in .github/release.yml at v0.37.0 -->
Thunder -> ThunderID by @brionmario in https://github.com/asgardeo/thunder/pull/2544/agent-types API by @thiva-k in https://github.com/asgardeo/thunder/pull/2550Full Changelog: https://github.com/asgardeo/thunder/compare/v0.36.0...v0.37.0
This Quickstart guide will help you get started with ThunderID quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run ThunderID either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.37.0 release of ThunderID and run it locally.
Download the distribution from the 0.37.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunderid-0.37.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunderid-0.37.0-macos-x64.zip |
| Linux | x64 | thunderid-0.37.0-linux-x64.zip |
| Linux | ARM64 | thunderid-0.37.0-linux-arm64.zip |
| Windows | x64 | thunderid-0.37.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunderid-0.37.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunderid-0.37.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run ThunderID using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.37.0/install/quick-start/docker-compose.yml
Start ThunderID
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the ThunderID Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
ThunderID provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.37.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.37.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.37.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.37.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.37.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.37.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.37.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.37.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.37.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.37.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.37.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.37.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.37.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.37.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of ThunderID, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
executionId value from the response.{"executionId":"<execution_id>","flowStatus":"INCOMPLETE", ...}
<execution_id> with the executionId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"executionId":"<execution_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"executionId":"<execution_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.36.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.36.0-macos-x64.zip |
| Linux | x64 | thunder-0.36.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.36.0-linux-arm64.zip |
| Windows | x64 | thunder-0.36.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.36.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.36.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.36.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.36.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.36.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.36.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.36.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.36.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.36.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.36.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.36.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.36.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.36.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.36.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.36.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.36.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.36.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
executionId value from the response.{"executionId":"<execution_id>","flowStatus":"INCOMPLETE", ...}
<execution_id> with the executionId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"executionId":"<execution_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"executionId":"<execution_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.35.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.35.0-macos-x64.zip |
| Linux | x64 | thunder-0.35.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.35.0-linux-arm64.zip |
| Windows | x64 | thunder-0.35.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.35.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.35.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.35.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.35.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.35.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.35.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.35.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.35.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.35.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.35.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.35.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.35.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.35.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.35.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.35.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.35.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.35.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
executionId value from the response.{"executionId":"<execution_id>","flowStatus":"INCOMPLETE", ...}
<execution_id> with the executionId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"executionId":"<execution_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"executionId":"<execution_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.34.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.34.0-macos-x64.zip |
| Linux | x64 | thunder-0.34.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.34.0-linux-arm64.zip |
| Windows | x64 | thunder-0.34.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.34.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.34.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.34.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.34.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.34.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.34.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.34.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.34.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.34.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.34.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.34.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.34.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.34.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.34.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.34.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.34.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.34.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
executionId value from the response.{"executionId":"<execution_id>","flowStatus":"INCOMPLETE", ...}
<execution_id> with the executionId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"executionId":"<execution_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"executionId":"<execution_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.33.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.33.0-macos-x64.zip |
| Linux | x64 | thunder-0.33.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.33.0-linux-arm64.zip |
| Windows | x64 | thunder-0.33.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.33.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.33.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.33.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.33.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.33.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.33.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.33.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.33.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.33.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.33.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.33.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.33.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.33.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.33.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.33.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.33.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.33.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.32.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.32.0-macos-x64.zip |
| Linux | x64 | thunder-0.32.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.32.0-linux-arm64.zip |
| Windows | x64 | thunder-0.32.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.32.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.32.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.32.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.32.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.32.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.32.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.32.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.32.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.32.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.32.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.32.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.32.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.32.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.32.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.32.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.32.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.32.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.31.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.31.0-macos-x64.zip |
| Linux | x64 | thunder-0.31.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.31.0-linux-arm64.zip |
| Windows | x64 | thunder-0.31.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.31.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.31.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.31.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.31.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.31.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.31.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.31.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.31.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.31.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.31.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.31.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.31.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.31.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.31.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.31.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.31.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.31.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.30.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.30.0-macos-x64.zip |
| Linux | x64 | thunder-0.30.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.30.0-linux-arm64.zip |
| Windows | x64 | thunder-0.30.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.30.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.30.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.30.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.30.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.30.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.30.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.30.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.30.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.30.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.30.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.30.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.30.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.30.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.30.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.30.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.30.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.30.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.29.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.29.0-macos-x64.zip |
| Linux | x64 | thunder-0.29.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.29.0-linux-arm64.zip |
| Windows | x64 | thunder-0.29.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.29.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.29.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.29.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.29.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.29.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.29.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.29.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.29.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.29.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.29.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.29.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.29.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.29.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.29.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.29.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.29.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.29.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.28.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.28.0-macos-x64.zip |
| Linux | x64 | thunder-0.28.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.28.0-linux-arm64.zip |
| Windows | x64 | thunder-0.28.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.28.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.28.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.28.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Thunder Console:
Open your browser and navigate to https://localhost:8090/console.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.28.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.28.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.28.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.28.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.28.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.28.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.28.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.28.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.28.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.28.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.28.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.28.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.28.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.28.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.27.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.27.0-macos-x64.zip |
| Linux | x64 | thunder-0.27.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.27.0-linux-arm64.zip |
| Windows | x64 | thunder-0.27.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.27.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.27.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.27.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.27.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.27.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.27.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.27.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.27.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.27.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.27.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.27.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.27.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.27.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.27.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.27.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.27.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.27.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2026 WSO2 LLC.
   | thunder-0.26.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.26.0-macos-x64.zip |
| Linux | x64 | thunder-0.26.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.26.0-linux-arm64.zip |
| Windows | x64 | thunder-0.26.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.26.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.26.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.26.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.26.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.26.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.26.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.26.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.26.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.26.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.26.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.26.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.26.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.26.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.26.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.26.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.26.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.26.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
   | thunder-0.25.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.25.0-macos-x64.zip |
| Linux | x64 | thunder-0.25.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.25.0-linux-arm64.zip |
| Windows | x64 | thunder-0.25.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.25.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.25.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.25.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.25.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.25.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.25.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.25.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.25.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.25.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.25.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.25.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.25.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.25.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.25.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.25.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.25.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.25.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.24.0 -->
at+jwt in access token header by @thiva-k in https://github.com/asgardeo/thunder/pull/1588Full Changelog: https://github.com/asgardeo/thunder/compare/v0.23.0...v0.24.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.24.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.24.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.24.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.24.0-macos-x64.zip |
| Linux | x64 | thunder-0.24.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.24.0-linux-arm64.zip |
| Windows | x64 | thunder-0.24.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.24.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.24.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.24.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.24.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.24.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.24.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.24.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.24.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.24.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.24.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.24.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.24.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.24.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.24.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.24.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.24.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.24.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.23.0 -->
Full Changelog: https://github.com/asgardeo/thunder/compare/v0.22.0...v0.23.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.23.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.23.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.23.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.23.0-macos-x64.zip |
| Linux | x64 | thunder-0.23.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.23.0-linux-arm64.zip |
| Windows | x64 | thunder-0.23.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.23.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.23.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.23.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.23.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.23.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.23.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.23.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.23.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.23.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.23.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.23.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.23.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.23.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.23.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.23.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.23.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.23.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.22.0 -->
/design API to replace /branding API by @brionmario in https://github.com/asgardeo/thunder/pull/1326Releases page in Thunder documentation by @LinukaAr in https://github.com/asgardeo/thunder/pull/1387index.html files by @brionmario in https://github.com/asgardeo/thunder/pull/1324Full Changelog: https://github.com/asgardeo/thunder/compare/v0.21.0...v0.22.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.22.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.22.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.22.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.22.0-macos-x64.zip |
| Linux | x64 | thunder-0.22.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.22.0-linux-arm64.zip |
| Windows | x64 | thunder-0.22.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.22.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.22.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.22.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.22.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.22.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.22.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.22.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.22.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.22.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.22.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.22.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.22.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.22.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.22.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.22.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.22.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.22.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.21.0 -->
assertion by @ThaminduDilshan in https://github.com/asgardeo/thunder/pull/1266required_attributes support for OAuth and auth assertion executor by @thiva-k in https://github.com/asgardeo/thunder/pull/1258claims support for OAuth flows by @thiva-k in https://github.com/asgardeo/thunder/pull/1288run command issues on Windows Platforms by @brionmario in https://github.com/asgardeo/thunder/pull/1302Full Changelog: https://github.com/asgardeo/thunder/compare/v0.20.0...v0.21.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.21.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.21.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.21.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.21.0-macos-x64.zip |
| Linux | x64 | thunder-0.21.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.21.0-linux-arm64.zip |
| Windows | x64 | thunder-0.21.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.21.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.21.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.16.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.21.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.21.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.21.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.21.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.21.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.21.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.21.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.21.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.21.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.21.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.21.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.21.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.21.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.21.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.20.0 -->
Full Changelog: https://github.com/asgardeo/thunder/compare/v0.19.0...v0.20.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.20.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.20.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.20.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.20.0-macos-x64.zip |
| Linux | x64 | thunder-0.20.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.20.0-linux-arm64.zip |
| Windows | x64 | thunder-0.20.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.20.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.20.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.16.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.20.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.20.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.20.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.20.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.20.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.20.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.20.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.20.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.20.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.20.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.20.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.20.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.20.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.20.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.19.0 -->
Full Changelog: https://github.com/asgardeo/thunder/compare/v0.18.0...v0.19.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.19.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.19.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.19.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.19.0-macos-x64.zip |
| Linux | x64 | thunder-0.19.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.19.0-linux-arm64.zip |
| Windows | x64 | thunder-0.19.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.19.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.19.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.16.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.19.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.19.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.19.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.19.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.19.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.19.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.19.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.19.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.19.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.19.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.19.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.19.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.19.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.19.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applic
Thunder is a modern, open-source identity management service designed for teams building secure, customizable authentication experiences across applications, services, and AI agents. It enables developers to design and orchestrate login, registration, and recovery flows using a flexible identity flow designer.
Designed for extensibility, scalability, and seamless containerized deployment, Thunder integrates naturally with microservices and DevOps environments—serving as the core identity layer for your cloud platform.
<!-- Release notes generated using configuration in .github/release.yml at v0.18.0 -->
Thunder branding by @brionmario in https://github.com/asgardeo/thunder/pull/1097Full Changelog: https://github.com/asgardeo/thunder/compare/v0.17.0...v0.18.0
This Quickstart guide will help you get started with WSO2 Thunder quickly. It walks you through downloading and running the product, trying out the sample app, and exploring registering a user, logging in, and using the Client Credentials flow.
You can run WSO2 Thunder either by downloading the release artifact or using the official Docker image.
Follow these steps to download the 0.18.0 release of WSO2 Thunder and run it locally.
Download the distribution from the 0.18.0 release
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | thunder-0.18.0-macos-arm64.zip |
| macOS | x64 (Intel) | thunder-0.18.0-macos-x64.zip |
| Linux | x64 | thunder-0.18.0-linux-x64.zip |
| Linux | ARM64 | thunder-0.18.0-linux-arm64.zip |
| Windows | x64 | thunder-0.18.0-win-x64.zip |
Unzip the product
Unzip the downloaded file using the following command:
unzip thunder-0.18.0-<os>-<arch>.zip
Navigate to the unzipped directory:
cd thunder-0.18.0-<os>-<arch>/
Setup the product
You need to setup the server with the initial configurations and data before starting the server for the first time.
If you are using a Linux or macOS machine:
./setup.sh
If you are using a Windows machine:
.\setup.ps1
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id>. You'll need it for the sample app configuration.
Start the product
If you are using a Linux or macOS machine:
./start.sh
If you are using a Windows machine:
.\start.ps1
The product will start on https://localhost:8090.
Follow these steps to run WSO2 Thunder using Docker Compose.
Download the Docker Compose file
Download the docker-compose.yml file using the following command:
curl -o docker-compose.yml https://raw.githubusercontent.com/asgardeo/thunder/v0.16.0/install/quick-start/docker-compose.yml
Start Thunder
Run the following command in the directory where you downloaded the docker-compose.yml file:
docker compose up
This will automatically:
Note the id of the sample app indicated with the log line [INFO] Sample App ID: <id> in the setup logs. You'll need it for the sample app configuration.
The product will start on https://localhost:8090.
Follow these steps to access the Developer Console:
Open your browser and navigate to https://localhost:8090/develop.
Log in using the admin credentials created during the initial data setup (admin / admin).
Thunder provides two sample applications to help you get started quickly:
@asgardeo/react for OAuth 2.0/OIDC authentication.Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-vanilla-0.18.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-vanilla-0.18.0-macos-x64.zip |
| Linux | x64 | sample-app-react-vanilla-0.18.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-vanilla-0.18.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-vanilla-0.18.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-vanilla-0.18.0-<os>-<arch>.zip
cd sample-app-react-vanilla-0.18.0-<os>-<arch>/
Configure the sample
Open app/runtime.json and set the applicationID to the sample app ID generated during "Setup the product":
{
"applicationID": "{your-application-id}"
}
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration options including OAuth redirect-based login.
Download the sample
| OS | Architecture | Download Link |
|---|---|---|
| macOS | ARM64 (Apple Silicon) | sample-app-react-sdk-0.18.0-macos-arm64.zip |
| macOS | x64 (Intel) | sample-app-react-sdk-0.18.0-macos-x64.zip |
| Linux | x64 | sample-app-react-sdk-0.18.0-linux-x64.zip |
| Linux | ARM64 | sample-app-react-sdk-0.18.0-linux-arm64.zip |
| Windows | x64 | sample-app-react-sdk-0.18.0-win-x64.zip |
Unzip and navigate to the sample app directory
unzip sample-app-react-sdk-0.18.0-<os>-<arch>.zip
cd sample-app-react-sdk-0.18.0-<os>-<arch>/
Start the sample
./start.sh
Open your browser and navigate to https://localhost:3000 to access the sample app.
📖 Refer to the
README.mdinside the extracted sample app for detailed configuration and troubleshooting.
The React Vanilla sample supports user self-registration and login:
Open https://localhost:3000 and click "Sign up" to register a new user.
<p align="left"> <img src="resources/images/sample-app-self-registration-basic.png" alt="Self Registration Username Password" width="400"> </p>
After registration, use the same credentials to "Sign In".
<p align="left"> <img src="resources/images/sample-app-login.png" alt="Login to Sample App" width="400"> </p>
Upon successful login, you'll see the home page with your access token.
To access the system APIs of Thunder, you need a token with system permissions. Follow the steps below to obtain a system API token.
<application_id> with the sample app ID generated during "Setup the product."curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"applicationId":"<application_id>","flowType":"AUTHENTICATION"}'
flowId value from the response.{"flowId":"<flow_id>","flowStatus":"INCOMPLETE", ...}
<flow_id> with the flowId value you extracted above.curl -k -X POST 'https://localhost:8090/flow/execute' \
-d '{"flowId":"<flow_id>", "inputs":{"username":"admin","password":"admin", "requested_permissions":"system"},"action": "action_001"}'
assertion value from the response.{"flowId":"<flow_id>","flowStatus":"COMPLETE","data":{},"assertion":"<assertion>"}
The Client Credentials flow is used to obtain an access token for machine-to-machine communication. This flow does not require user interaction and is typically used for server-to-server communication.
To try out the Client Credentials flow, follow these steps:
Create a Client Application
Application creation is secured functionality, so you first need to obtain a system API token as mentioned in the "Obtain System API Token" section above.
Run the following command, replacing <assertion> with the assertion value obtained from the previous step.
curl -kL -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' https://localhost:8090/applications \
-H 'Authorization: Bearer <assertion>' \
-d '{
"name": "Test Sample App",
"description": "Initial testing App",
"inbound_auth_config": [
{
"type": "oauth2",
"config": {
"client_id": "<client_id>",
"client_secret": "<client_secret>",
"redirect_uris": [
"https://localhost:3000"
],
"grant_types": [
"client_credentials"
],
"token_endpoint_auth_method": "client_secret_basic",
"pkce_required": false,
"public_client": false,
"scopes": ["api:read", "api:write"]
}
}
]
}'
Obtain an Access Token
Use the following cURL command to obtain an access token using the Client Credentials flow. Make sure to replace the <client_id> and <client_secret> with the values you used when creating the client application.
curl -k -X POST https://localhost:8090/oauth2/token \
-d 'grant_type=client_credentials' \
-u '<client_id>:<client_secret>'
Licenses this source under the Apache License, Version 2.0 (LICENSE), You may not use this file except in compliance with the License.
(c) Copyright 2025 WSO2 LLC.
One column per month.