# Connect to Claude Desktop
Source: https://docs.shuriken.trade/agent-kit/connect-claude
Step-by-step guide to connect your Shuriken Agent Key to Claude Desktop.
This guide gets Claude Desktop connected to Shuriken in about 2 minutes. Once set up, you can ask Claude to scan your alpha, research tokens, check your portfolio, and trade - all from a conversation.
**Time required:** About 2 minutes.
## Prerequisites
* [Claude Desktop](https://claude.ai/download) installed (available for macOS and Windows)
* [Node.js](https://nodejs.org) installed (required for the `mcp-remote` bridge)
* A Shuriken Agent Key ([create one here](/agent-kit/create-agent-key) if you haven't already)
## Step-by-step setup
If you just created your key, copy it from the setup screen. It starts with `sk_`.
If you already closed that screen, you'll need to [create a new key](/agent-kit/create-agent-key) - keys are only shown once.
Claude Desktop stores its MCP config in a file called `claude_desktop_config.json`.
**Option A: Through Claude Desktop settings**
1. Open Claude Desktop
2. Click the **Claude** menu in your system menu bar (top of screen on macOS, top of window on Windows)
3. Select **Settings**
4. Go to the **Developer** tab
5. Click **Edit Config**
This opens the config file directly.
**Option B: Open the file manually**
```
~/Library/Application Support/Claude/claude_desktop_config.json
```
Open Finder, press `Cmd+Shift+G`, and paste the path above.
```
%APPDATA%\Claude\claude_desktop_config.json
```
Press `Win+R`, paste the path above, and hit Enter. If the file doesn't exist, create it.
The full path is usually: `C:\Users\YOUR_USERNAME\AppData\Roaming\Claude\claude_desktop_config.json`
Paste the following into your config file. Replace `YOUR_AGENT_KEY` with the key you copied in step 1.
**Why `mcp-remote`?** Claude Desktop supports remote MCP servers through its built-in Connectors feature (Settings > Connectors), but that requires OAuth authentication. Since Shuriken uses API key authentication via custom headers, the `mcp-remote` bridge is needed to pass those headers through `claude_desktop_config.json`.
**Node.js required.** The config below uses `npx` to run the `mcp-remote` bridge. If you don't have [Node.js](https://nodejs.org) installed, this step will fail silently.
**If the file is empty or doesn't exist**, paste this entire block:
```json claude_desktop_config.json theme={null}
{
"mcpServers": {
"Shuriken": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://api.shuriken.trade/mcp",
"--header",
"Authorization: AgentKey YOUR_AGENT_KEY"
]
}
}
}
```
```json claude_desktop_config.json theme={null}
{
"mcpServers": {
"Shuriken": {
"command": "cmd",
"args": [
"/c",
"npx",
"-y",
"mcp-remote",
"https://api.shuriken.trade/mcp",
"--header",
"Authorization: AgentKey YOUR_AGENT_KEY"
]
}
}
}
```
Windows can't execute `npx` directly as a process β it's a `.cmd` script, not a real executable. The `cmd /c` wrapper is the official workaround. This is a known Claude Desktop limitation, not specific to Shuriken.
**If your config already has other MCP servers or preferences**, add the `"Shuriken"` block inside the existing `"mcpServers"` object. Keep any other configuration (like `preferences`) as-is:
```json claude_desktop_config.json theme={null}
{
"mcpServers": {
"your-existing-server": {
"...": "..."
},
"Shuriken": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://api.shuriken.trade/mcp",
"--header",
"Authorization: AgentKey YOUR_AGENT_KEY"
]
}
},
"preferences": {
"...your existing preferences...": "..."
}
}
```
```json claude_desktop_config.json theme={null}
{
"mcpServers": {
"your-existing-server": {
"...": "..."
},
"Shuriken": {
"command": "cmd",
"args": [
"/c",
"npx",
"-y",
"mcp-remote",
"https://api.shuriken.trade/mcp",
"--header",
"Authorization: AgentKey YOUR_AGENT_KEY"
]
}
},
"preferences": {
"...your existing preferences...": "..."
}
}
```
Make sure there's a comma between each server entry. Missing commas are the most common cause of connection failures.
Save the file, then **completely quit and relaunch Claude Desktop**. The MCP connection won't activate until you restart.
On macOS, make sure to quit from the menu bar (Claude > Quit Claude), not just close the window.
After restarting, look for an **MCP tools indicator** (a small hammer icon) in the bottom-right corner of the chat input box. Click it to see the available Shuriken tools.
Try a test prompt:
```
What tokens were called in my Discord today?
```
```
What's my SOL balance?
```
Claude will ask for your approval before using each tool for the first time. Click **Allow** to let it proceed.
If you see results, you're all set. Claude is now connected to Shuriken.
## Troubleshooting
* Make sure you saved the config file
* Make sure you fully quit and restarted Claude Desktop
* Check for JSON syntax errors (missing commas, mismatched brackets)
* Verify that Node.js is installed by running `node --version` in your terminal
* Check Claude's logs for errors:
* **macOS:** `~/Library/Logs/Claude/mcp.log`
* **Windows:** `%APPDATA%\Claude\logs\mcp.log`
* Double-check that your Agent Key is correct (starts with `sk_`)
* Make sure you included the `AgentKey ` prefix before the key (with a space)
* Check that the key hasn't been revoked on the [Agent Keys dashboard](https://app.shuriken.trade/agents)
This usually means Windows can't find `npx` as a direct executable. Make sure your config uses the `cmd /c` wrapper:
```json theme={null}
"command": "cmd",
"args": ["/c", "npx", "mcp-remote", ...]
```
Also verify that Node.js is installed and `npx` is available in your PATH by running `npx --version` in Command Prompt.
The first time Claude Desktop starts with this config, `npx` downloads the `mcp-remote` package in the background. This can take 10-30 seconds with no visible feedback. Subsequent launches will be fast since the package is cached.
This is normal. Claude Desktop asks you to approve tool usage for safety. You can click **Allow for this chat** to approve all tool calls in the current conversation.
# Connect to Claude Code
Source: https://docs.shuriken.trade/agent-kit/connect-claude-code
Step-by-step guide to connect your Shuriken Agent Key to Claude Code.
This guide gets Claude Code connected to Shuriken in about a minute. Once set up, you can ask Claude to scan your alpha, research tokens, check your portfolio, and trade - all from the terminal.
**Time required:** About 1 minute.
## Prerequisites
* [Claude Code](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview) installed
* A Shuriken Agent Key ([create one here](/agent-kit/create-agent-key) if you haven't already)
## Step-by-step setup
If you just created your key, copy it from the setup screen. It starts with `sk_`.
If you already closed that screen, you'll need to [create a new key](/agent-kit/create-agent-key) - keys are only shown once.
Claude Code supports native HTTP transport, so no bridge or extra dependencies are needed. This works the same on macOS, Windows, and Linux.
**Option A: CLI command (recommended)**
Run this in your terminal, replacing `YOUR_AGENT_KEY` with the key you copied in step 1:
```bash theme={null}
claude mcp add --transport http Shuriken https://api.shuriken.trade/mcp \
--header "Authorization: AgentKey YOUR_AGENT_KEY"
```
**Option B: Edit `.mcp.json` manually**
Add the following to your `.mcp.json` file (in your project root or `~/.claude/.mcp.json` for global access). Replace `YOUR_AGENT_KEY` with your key.
**If the file is empty or doesn't exist**, paste this entire block:
```json .mcp.json theme={null}
{
"mcpServers": {
"Shuriken": {
"type": "http",
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
**If you already have other MCP servers**, add the `"Shuriken"` block inside the existing `"mcpServers"` object:
```json .mcp.json theme={null}
{
"mcpServers": {
"your-existing-server": {
"...": "..."
},
"Shuriken": {
"type": "http",
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
Make sure there's a comma between each server entry. Missing commas are the most common cause of connection failures.
Start a new Claude Code session and try one of these prompts:
```
What tokens were called in my Discord today?
```
```
What's my SOL balance?
```
Claude will ask for your approval before using each tool for the first time. Type **y** to let it proceed.
If you see results, you're all set. Claude Code is now connected to Shuriken.
## Troubleshooting
* If you used the CLI command, start a new Claude Code session for the changes to take effect
* If you edited `.mcp.json` manually, check for JSON syntax errors (missing commas, mismatched brackets)
* Make sure the file is in the right location (project root for project-level, `~/.claude/.mcp.json` for global)
* Run `claude mcp list` to see if Shuriken is registered
* Double-check that your Agent Key is correct (starts with `sk_`)
* Make sure you included the `AgentKey ` prefix before the key (with a space)
* Check that the key hasn't been revoked on the [Agent Keys dashboard](https://app.shuriken.trade/agents)
# Connect to Cursor
Source: https://docs.shuriken.trade/agent-kit/connect-cursor
Step-by-step guide to connect your Shuriken Agent Key to Cursor.
This guide gets Cursor connected to Shuriken in about 2 minutes. Once set up, you can ask your AI to scan alpha, research tokens, check your portfolio, and trade - all from the chat panel.
**Time required:** About 2 minutes.
## Prerequisites
* [Cursor](https://cursor.com) installed on your computer with a **Pro plan or higher** (MCP requires Agent mode, which is not available on the free plan)
* A Shuriken Agent Key ([create one here](/agent-kit/create-agent-key) if you haven't already)
## Step-by-step setup
If you just created your key, copy it from the setup screen. It starts with `sk_`.
If you already closed that screen, you'll need to [create a new key](/agent-kit/create-agent-key) - keys are only shown once.
You need to edit a file called `mcp.json`. This is where Cursor stores its MCP server connections.
**Option A: Use the Command Palette (recommended)**
1. Open Cursor
2. Press `Ctrl+Shift+P` (Windows/Linux) or `Cmd+Shift+P` (macOS)
3. Type **MCP** and select **"Cursor Settings: Open MCP Settings"**
4. This opens your `mcp.json` file
**Option B: Open the file manually**
The file lives in your home directory:
```
C:\Users\YOUR_USERNAME\.cursor\mcp.json
```
Replace `YOUR_USERNAME` with your Windows username.
Quick way to get there: press `Win+R`, type `%USERPROFILE%\.cursor` and hit Enter. Look for `mcp.json`. If it doesn't exist, create it.
```
~/.cursor/mcp.json
```
Open Finder, press `Cmd+Shift+G`, and paste the path above.
```
~/.cursor/mcp.json
```
Paste the following into your `mcp.json` file. Replace `YOUR_AGENT_KEY` with the key you copied in step 1.
**If the file is empty or doesn't exist**, paste this entire block:
```json mcp.json theme={null}
{
"mcpServers": {
"Shuriken": {
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
**If you already have other MCP servers**, add the `"Shuriken"` block inside the existing `"mcpServers"` object:
```json mcp.json theme={null}
{
"mcpServers": {
"your-existing-server": {
"...": "..."
},
"Shuriken": {
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
Make sure there's a comma between each server entry. Missing commas are the most common cause of connection failures.
Save the file, then **completely quit and reopen Cursor**. The MCP connection won't activate until you restart.
Open a new chat in Cursor (the Composer or Agent panel) and try one of these prompts:
```
What tokens were called in my Discord today?
```
```
What's my SOL balance?
```
If Shuriken is connected, you'll see the agent use Shuriken tools to answer your question. The tool names will show up in the chat (like `get_recent_calls` or `get_balances`).
If you see results, you're all set. Your AI agent is now connected to Shuriken.
## Troubleshooting
* Make sure you saved the `mcp.json` file
* Make sure you fully quit and restarted Cursor (not just closed the window)
* Check that there are no syntax errors in your JSON (missing commas, extra commas, mismatched brackets)
* Try opening the Command Palette (`Ctrl+Shift+P`) and searching for "MCP" - you should see Shuriken listed
* Double-check that your Agent Key is correct (starts with `sk_`)
* Make sure you included the `AgentKey ` prefix before the key (with a space)
* Check that the key hasn't been revoked on the [Agent Keys dashboard](https://app.shuriken.trade/agents)
Common mistakes:
* Missing comma between server entries
* Trailing comma after the last entry
* Using single quotes instead of double quotes
* Missing closing brackets
Paste your `mcp.json` into [jsonlint.com](https://jsonlint.com) to check for syntax errors.
The file might not exist yet. Create a new file called `mcp.json` in the `.cursor` folder inside your home directory and paste the full config block from step 3.
## Multiple Agent Keys
You can connect multiple Shuriken Agent Keys to Cursor at the same time - for example, one read-only key for research and one with trading enabled. Give each one a different name:
```json mcp.json theme={null}
{
"mcpServers": {
"shuriken-research": {
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey sk_YOUR_READ_ONLY_KEY"
}
},
"shuriken-trading": {
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey sk_YOUR_TRADING_KEY"
}
}
}
}
```
When using multiple keys, each one appears as a separate MCP server in Cursor. The AI will have access to all tools from all connected keys.
# Connect to OpenClaw
Source: https://docs.shuriken.trade/agent-kit/connect-openclaw
Step-by-step guide to connect your Shuriken Agent Key to OpenClaw.
This guide gets your OpenClaw agent connected to Shuriken in about 2 minutes. Once set up, your agent can monitor your alpha groups, research tokens, check your portfolio, and execute trades - all through WhatsApp, Telegram, Discord, or the built-in Control UI.
**Time required:** About 2 minutes.
## Prerequisites
* [OpenClaw](https://openclaw.ai) installed and running (`openclaw gateway status` should show it's active)
* A Shuriken Agent Key ([create one here](/agent-kit/create-agent-key) if you haven't already)
## Step-by-step setup
If you just created your key, copy it from the setup screen. It starts with `sk_`.
If you already closed that screen, you'll need to [create a new key](/agent-kit/create-agent-key) - keys are only shown once.
OpenClaw stores its config in a JSON5 file called `openclaw.json`.
**Option A: Use the CLI (recommended)**
```bash theme={null}
openclaw configure
```
**Option B: Use the Control UI**
Open [http://127.0.0.1:18789](http://127.0.0.1:18789) in your browser and go to the **Config** tab.
**Option C: Edit the file directly**
```
%USERPROFILE%\.openclaw\openclaw.json
```
```
~/.openclaw/openclaw.json
```
Add the following `mcpServers` block to your `openclaw.json`. Replace `YOUR_AGENT_KEY` with the key you copied in step 1.
**If you don't have any MCP servers yet**, add this to your config:
```json5 openclaw.json theme={null}
{
// ...your existing config...
mcpServers: {
Shuriken: {
url: "https://api.shuriken.trade/mcp",
headers: {
Authorization: "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
**If you already have MCP servers**, add the `shuriken` block inside the existing `mcpServers` object:
```json5 openclaw.json theme={null}
{
mcpServers: {
"your-existing-server": {
// ...
},
Shuriken: {
url: "https://api.shuriken.trade/mcp",
headers: {
Authorization: "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
OpenClaw uses JSON5 format, so you don't need to quote keys or worry about trailing commas. But standard JSON also works.
OpenClaw watches the config file and applies changes automatically - no restart needed in most cases.
If the tools don't appear, restart the gateway:
```bash theme={null}
openclaw gateway restart
```
Open the Control UI at [http://127.0.0.1:18789](http://127.0.0.1:18789) or message your agent through any connected channel (WhatsApp, Telegram, Discord, etc.) and try:
```
What tokens were called in my Discord today?
```
```
What's my SOL balance?
```
If you see results from Shuriken, you're all set. Your OpenClaw agent is now connected.
## Troubleshooting
OpenClaw strictly validates its config. If the gateway won't start after your changes:
```bash theme={null}
openclaw doctor --fix
```
This will diagnose and suggest repairs. Common issues: unknown keys, malformed types, or invalid JSON5 syntax.
* Make sure the `mcpServers` block is at the root level of your config (not nested inside another section)
* Check that your Agent Key is correct (starts with `sk_`)
* Make sure you included the `AgentKey ` prefix before the key (with a space)
* Try restarting the gateway: `openclaw gateway restart`
* Double-check your Agent Key hasn't been revoked on the [Agent Keys dashboard](https://app.shuriken.trade/agents)
* Make sure the key has the permissions needed for the tool you're trying to use (see [Permissions](/agent-kit/permissions))
# Other MCP Clients
Source: https://docs.shuriken.trade/agent-kit/connect-other
Connect Shuriken to any MCP-compatible AI tool using the generic setup guide.
Shuriken's Agent Kit works with any AI tool that supports MCP. If your tool isn't listed in our dedicated guides, you'll be connected in a few minutes using the setup below.
## What you need
1. **An MCP-compatible AI tool** - check your tool's documentation for MCP support
2. **A Shuriken Agent Key** - [create one here](/agent-kit/create-agent-key) if you haven't already
## Connection details
Shuriken uses a **remote HTTP MCP server**. This means your AI tool connects to Shuriken over the internet - no local installation, no `npx` commands, no Node.js required.
Here are the details you'll need:
| Field | Value |
| ------------------ | -------------------------------- |
| **Server URL** | `https://api.shuriken.trade/mcp` |
| **Transport type** | HTTP (Streamable HTTP) |
| **Authentication** | Header-based |
| **Header name** | `Authorization` |
| **Header value** | `AgentKey YOUR_AGENT_KEY` |
Replace `YOUR_AGENT_KEY` with your actual key (starts with `sk_`).
## Generic JSON config
Most MCP clients use a JSON config file. The exact format varies, but here are the two most common patterns:
### Pattern 1: `url` + `headers`
Used by **Cursor**, **Claude Desktop**, and most MCP clients.
```json theme={null}
{
"mcpServers": {
"Shuriken": {
"url": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
### Pattern 2: `serverUrl` + `headers`
Used by **Windsurf** and some other clients.
```json theme={null}
{
"mcpServers": {
"Shuriken": {
"serverUrl": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
Not sure which pattern your tool uses? Try Pattern 1 first. If it doesn't work, try Pattern 2. The only difference is `"url"` vs `"serverUrl"`.
## Config file locations
For reference, here's where common tools store their MCP config:
| Tool | Config file location |
| ---------------------------- | ----------------------------------------------------------------- |
| **Cursor** | `~/.cursor/mcp.json` |
| **Claude Desktop (macOS)** | `~/Library/Application Support/Claude/claude_desktop_config.json` |
| **Claude Desktop (Windows)** | `%APPDATA%\Claude\claude_desktop_config.json` |
| **Windsurf** | `~/.codeium/windsurf/mcp_config.json` |
| **Claude Code** | `.mcp.json` (project root or `~/.claude/.mcp.json` global) |
| **OpenClaw** | `~/.openclaw/openclaw.json` (under `mcpServers` key) |
## Verify the connection
After adding the config and restarting your tool, try one of these test prompts:
```
What tokens were called in my Discord today?
```
```
What's my SOL balance?
```
If your agent responds with real data from Shuriken, the connection is working.
## Available tools
Once connected, your agent will have access to these tools (depending on your key's [permissions](/agent-kit/permissions)):
| Tool | Permission required | What it does |
| --------------------- | ------------------- | ------------------------------------------- |
| `get_wallets` | Read Wallets | List your wallet addresses |
| `get_balances` | Read Balances | View token balances with USD values |
| `get_positions` | Read Balances | View all holdings with PnL data |
| `get_token_position` | Read Balances | Check a specific token position |
| `get_alpha_sources` | Read Alpha | See your connected Discord/Telegram sources |
| `get_recent_calls` | Read Alpha | Recent token mentions from your groups |
| `get_global_calls` | Read Alpha | Trending KOL mentions from X |
| `get_token_mentions` | Read Alpha | Detailed mention history for a token |
| `search_tokens` | Read Tokens | Search tokens by name or symbol |
| `get_token_info` | Read Tokens | Token metadata and market data |
| `get_token_stats` | Read Tokens | Volume, txn counts, price changes |
| `plan_trade` | Get Quotes | Get a trade quote (no execution) |
| `execute_trade` | Execute Trades | Submit a trade for execution |
| `get_task_status` | Execute Trades | Check trade status |
| `get_agent_key_usage` | Always available | Check your key's usage and remaining limits |
If a tool doesn't appear in your client, your Agent Key might not have the required permission. Check your key's permissions on the [Agent Keys dashboard](https://app.shuriken.trade/agents) or [create a new key](/agent-kit/create-agent-key) with the right access.
## Need help?
If your MCP client isn't listed here and you're having trouble connecting, reach out on our [Telegram support](https://t.me/ShurikenSupportBot).
# Connect to Windsurf
Source: https://docs.shuriken.trade/agent-kit/connect-windsurf
Step-by-step guide to connect your Shuriken Agent Key to Windsurf.
This guide gets Windsurf connected to Shuriken in about 2 minutes. Once set up, you can ask Cascade to scan alpha, research tokens, check your portfolio, and trade - all from the chat panel.
**Time required:** About 2 minutes.
## Prerequisites
* [Windsurf](https://windsurf.com) installed on your computer
* A Shuriken Agent Key ([create one here](/agent-kit/create-agent-key) if you haven't already)
## Step-by-step setup
If you just created your key, copy it from the setup screen. It starts with `sk_`.
If you already closed that screen, you'll need to [create a new key](/agent-kit/create-agent-key) - keys are only shown once.
Windsurf stores its MCP config in a file called `mcp_config.json`.
Windsurf uses a **different config file and format** than Cursor and Claude Desktop. Don't copy configs from those tools directly - the key name for the URL field is different.
**Option A: Use the Command Palette (recommended)**
1. Open Windsurf
2. Press `Ctrl+Shift+P` (Windows/Linux) or `Cmd+Shift+P` (macOS)
3. Type **MCP** and select **"Windsurf: Configure MCP Servers"**
4. This opens your `mcp_config.json` file
**Option B: Through the Cascade panel**
1. Open the Cascade AI panel
2. Click the **MCPs** icon
3. Click **Configure**
**Option C: Open the file manually**
```
%USERPROFILE%\.codeium\windsurf\mcp_config.json
```
Press `Win+R`, paste `%USERPROFILE%\.codeium\windsurf` and hit Enter. Look for `mcp_config.json`. If it doesn't exist, create it.
```
~/.codeium/windsurf/mcp_config.json
```
```
~/.codeium/windsurf/mcp_config.json
```
Paste the following into your `mcp_config.json` file. Replace `YOUR_AGENT_KEY` with the key you copied in step 1.
**If the file is empty or doesn't exist**, paste this entire block:
```json mcp_config.json theme={null}
{
"mcpServers": {
"Shuriken": {
"serverUrl": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
**If you already have other MCP servers**, add the `"Shuriken"` block inside the existing `"mcpServers"` object:
```json mcp_config.json theme={null}
{
"mcpServers": {
"your-existing-server": {
"...": "..."
},
"Shuriken": {
"serverUrl": "https://api.shuriken.trade/mcp",
"headers": {
"Authorization": "AgentKey YOUR_AGENT_KEY"
}
}
}
}
```
**Important:** Windsurf uses `"serverUrl"` (not `"url"`). If you copy config from the Cursor or Claude Desktop guides, make sure to change `"url"` to `"serverUrl"` or the connection will fail silently.
Save the file. In Windsurf, you can either:
* **Restart Windsurf** completely, or
* Click the **refresh button** next to the MCPs section in the Cascade panel
Unlike Cursor and Claude Desktop, Windsurf can sometimes pick up config changes without a full restart. But if it doesn't work, restart to be safe.
Open a chat in the Cascade panel and try one of these prompts:
```
What tokens were called in my Discord today?
```
```
What's my SOL balance?
```
If Shuriken is connected, Cascade will use Shuriken tools to answer your question.
If you see results, you're all set. Windsurf is now connected to Shuriken.
## Troubleshooting
* Make sure you saved the `mcp_config.json` file
* Try clicking the refresh button in the Cascade panel
* If that doesn't work, fully restart Windsurf
* Check that there are no JSON syntax errors
* Double-check that your Agent Key is correct (starts with `sk_`)
* Make sure you're using `"serverUrl"` (not `"url"`)
* Make sure you included the `AgentKey ` prefix before the key (with a space)
* Check that the key hasn't been revoked on the [Agent Keys dashboard](https://app.shuriken.trade/agents)
Windsurf uses `"serverUrl"` while Cursor and Claude Desktop use `"url"`. Change the field name:
```
"url": "https://..." <-- Cursor / Claude Desktop
"serverUrl": "https://..." <-- Windsurf
```
# Create an Agent Key
Source: https://docs.shuriken.trade/agent-kit/create-agent-key
Pick a preset, name your agent, and you're done in 30 seconds. No code, no server, no monthly fee.
An Agent Key connects your AI tool to your Shuriken account. It controls exactly what the AI is allowed to do - from reading token prices to executing trades - and every limit is enforced server-side before the agent ever starts. Pick a preset template and you're done in 30 seconds. Or build a custom key with the exact permissions you need.
Think of it like giving someone a key to your house, except you get to choose which rooms they can enter.
## Create a preset key
Templates are pre-configured keys designed for common use cases. Pick one, give it a name, and you're done in 30 seconds.
Click your **profile icon** in the top-right corner of the terminal, then select **Agent Keys**.
This opens the template selection modal.
Pick the template that fits your use case (see below for what each one does).
### Read-only templates
These keys **cannot trade or move funds**. They're safe to experiment with.
**Best for:** Monitoring your Discord and Telegram alpha groups through AI.
**Can do:**
* See token mentions from your connected groups
* Look up any token's price, stats, and market data
* Track which calls are performing best
**Cannot do:**
* See your wallet balances
* Execute any trades
**Best for:** Asking your AI about your holdings, balances, and getting trade quotes.
**Can do:**
* View your wallet addresses and balances
* Check token holdings and profit/loss
* Look up token prices and stats
* Get trade quotes (without executing)
**Cannot do:**
* Execute any trades
### Trading templates
These keys **can move real funds** from your wallet. They come with built-in safety limits.
Trading keys give the AI permission to buy and sell tokens using your wallet. Only create one if you understand the risks and trust your AI setup.
**Best for:** Letting the AI buy tokens that match your criteria automatically.
**Can do:** Everything (wallets, balances, alpha, tokens, quotes, and execution)
**Default limits:**
* Max \$50 per trade
* Max \$500 per day
**Best for:** Executing on alpha calls instantly as they come in.
**Can do:** Wallets, balances, tokens, quotes, and execution
**Default limits:**
* Max \$25 per trade
* Max \$250 per day
## Set up your template key
Click the template card that fits your use case.
Give it a descriptive name so you can identify it later (e.g., "My Alpha Scout" or "Cursor Trading Bot").
Click **Create** and your key will be generated instantly.
## Create a custom key
If none of the templates fit, you can build your own key with exactly the permissions you need.
Click **Create a custom agent key with full control** at the bottom of the template modal.
Enter a name for your agent (e.g., "Research Only" or "Cursor Trading Bot").
Toggle the permissions your agent needs. See the [Permissions guide](/agent-kit/permissions) for a detailed explanation of each one.
| Permission | What it does |
| ------------------ | ------------------------------------------------ |
| **Read Wallets** | View your wallet addresses |
| **Read Balances** | View token balances and USD values |
| **Read Alpha** | Access token mentions from your Discord/Telegram |
| **Read Tokens** | Look up token prices, stats, and market data |
| **Get Quotes** | Create trade plans and get price quotes |
| **Execute Trades** | Actually move real funds (buy/sell tokens) |
You can always start with fewer permissions and create a new key later with more access. When in doubt, leave **Execute Trades** off.
Choose whether the key can access **all your wallets** or only **specific ones**.
When you turn on Execute Trades, additional safety controls appear. See [Permissions & Safety](/agent-kit/permissions) for full details on:
* Buy/sell limits per day and per trade
* Max sell size (percentage of a position)
* Execution rate limits (trades per hour, per day)
* Max concurrent trades
* Slippage cap
* Custom gas fees and MEV protection
Scroll down to the **Shuriken AI** section at the bottom of the modal. Check the **Telegram** box to allow this key to be used with [@shuriken\_trade\_bot](https://t.me/shuriken_trade_bot) for natural language trading.
Enabling Telegram lets you message the Shuriken bot in plain English - "whats trending", "buy 0.1 SOL of BONK", "show my balance" - and it executes within the limits set on this key. See the [Natural Language Trading guide](/agent-kit/nlp-telegram) for setup details.
Click **Create Key** to generate your Agent Key.
## Copy your key
**Copy your key immediately.** You will not be able to see it again after closing this screen. If you lose it, you'll need to create a new one.
After creating your key, you'll see:
* **Your Agent Key** - a string starting with `sk_` that you'll paste into your AI tool
* **Setup instructions** - ready-to-copy config snippets for Cursor, Claude Desktop, and other tools
Copy the key and store it somewhere safe. Then head to the setup guide for your AI tool:
## Managing your keys
You can view, pause, or revoke your Agent Keys at any time from the [Agent Keys dashboard](https://app.shuriken.trade/agents).
* **Pause** - temporarily disable a key without deleting it
* **Revoke** - permanently delete a key (the AI will immediately lose access)
It's good practice to create separate keys for different purposes. For example, one read-only key for research and a separate trading key with strict limits.
## Monitor your agent's activity
Every action your agent takes is logged in real-time on the Agent Keys dashboard. Click any key in the sidebar to see its activity feed.
The activity log shows:
* **Every tool call** - token lookups, balance checks, alpha queries, and more
* **Trade quotes** - including the token, amount, and estimated value
* **Timestamps** - so you can see exactly when each action happened
* **Status** - whether the key is active, paused, or idle
This gives you full visibility into what your AI is doing with your account. If anything looks off, you can **pause or revoke** the key instantly from the same page.
The activity dashboard is available at [app.shuriken.trade/agents](https://app.shuriken.trade/agents). Bookmark it for quick access.
# Shuriken Labs
Source: https://docs.shuriken.trade/agent-kit/labs/overview
Build an agent in the browser. Wire it to a schedule, your trades, or an API call. It runs while you don't.
Shuriken Labs is the no-code way to build a trading agent. Write a task prompt, pick the tools it can use, set the limits, and decide when it fires. No code, no server. You can be running in a few minutes.
Every Terminal user as of 2026-05-04 was given \$5 USDC of AI billing credit. It's already in your account. That's enough to run most agents for a couple of weeks.
## What an agent is
The instructions you write once. "Find tokens called by 3+ alpha groups in the last hour with under \$5M cap. Show me the top 5."
The same trading, lookup, and alpha tools you use yourself. Buys, sells, balances, token stats, group calls, on-chain data.
When the agent fires. On a cadence, after your own trades, or via an API call.
The agent runs under a scoped agent key. Per-trade caps, daily limits, and wallet restrictions are enforced server-side.
## The build, trigger, run loop
1. **Build the agent** in [Shuriken Labs](https://app.shuriken.trade/labs). Pick a starter or write the task prompt yourself.
2. **Wire a trigger** so the agent knows when to fire. See [Triggers](/agent-kit/labs/triggers) for the three options.
3. **It runs** under your scoped agent key. Every limit and slippage cap you've already set still applies.
4. **You review** every session in the run history, with the full transcript and tool calls.
The agent can never override the limits on its key. If a trade would exceed your per-trade cap, Shuriken rejects it before it executes. No matter what the prompt asks for.
## Three ways to fire it
**[On a schedule](/agent-kit/labs/triggers#on-a-schedule)** runs the agent on a cron-style cadence. *"Every morning at 09:00 UTC, summarize calls from my Discords overnight, filtered to under \$1M market cap."*
**[When I make a trade](/agent-kit/labs/triggers#when-i-make-a-trade)** fires the agent right after you buy or sell. *"After every buy on Solana, watch the position and tell me when it hits +50% or -25%."*
**[Allow API calls](/agent-kit/labs/triggers#allow-api-calls)** lets you invoke the agent from a webhook, an MCP client, or any HTTP request. *"Call the agent from a Telegram bot when it sees a contract paste, and have it run a rug check."*
You can attach more than one. A research agent can be on a daily schedule *and* callable on demand from your Claude Desktop session at the same time.
## Stop button and monitoring
The chat panel has a Stop button. Clicking it halts the upstream run, not just your local stream, so your billing stops at the same moment. The button shows a "Stoppingβ¦" loader for a second while the upstream confirms.
Every run shows up in the agent's session list with the full transcript, every tool call, and the result. Open a session to see exactly what the agent did and how long it took.
## Credits and billing
Every Terminal user as of 2026-05-04 received \$5 USDC of AI billing credit, retroactively. It's already in your account.
Top up at any time with USDC, or swap from the chain's native gas asset (SOL, ETH, BNB) into USDC in one step from the top-up modal.
Each run charges only the model time it actually used. The Stop button is the safest way to bound a run that's drifting. If you hit zero balance, scheduled and trade triggers stop firing until you top up.
## Get started
Open Labs and pick a starter, or build your own from scratch. Takes about 2 minutes.
Wire your agent to a schedule, your own trades, or an API call.
New to agent keys? [Create one](/agent-kit/create-agent-key) first. Labs uses the same key system as the rest of Agent Kit, so the limits you set on the key apply to every agent that runs under it.
# Triggers
Source: https://docs.shuriken.trade/agent-kit/labs/triggers
Three ways your Labs agent can fire. Schedule it, react to your own trades, or invoke it from an API.
Triggers decide when an agent runs. You can attach more than one. Each fires independently and produces its own session you can review later from the run history.
## Three trigger types
Fire on a recurring cadence. Cron, but with a friendly UI.
Fire after your own buys, sells, or both. With cooldown.
Invoke from a webhook, an MCP client, or any HTTP request.
## On a schedule
Schedules run the agent on a recurring cadence. Useful for morning briefings, weekly recaps, and any hands-off task you want to wake up to.
**Frequencies:** minutely, hourly, daily, weekly, monthly. Each one shows the relevant pickers: weekday for weekly, day-of-month for monthly, hour and minute for daily and below.
**Timezone:** required. Defaults to your browser's timezone so a schedule respects your local time, not UTC. You can pick any timezone from the dropdown.
**Example: morning briefing.**
```
What you set: Daily, 09:00, America/New_York, MonβFri.
When it fires: Every weekday at 09:00 New York time. The session lands in your run history.
```
**Example: weekly recap.**
```
What you set: Weekly, Sunday, 22:00 UTC.
When it fires: Every Sunday at 22:00 UTC. One session per week.
```
The agent runs under your scoped agent key. Per-trade and daily limits still apply, so a runaway schedule can't exceed them. If you hit your daily cap mid-schedule, the next fire skips trades and just reports.
## When I make a trade
Trade triggers fire right after *you* execute a trade through Shuriken (Terminal, Telegram, NLP, or the API). They do not fire off other people's wallets or alpha calls.
**Action filter:** buy, sell, or any. You can attach two trade triggers at once with different actions (one for buy, one for sell), but only one configured as `any`.
**Cooldown:** default 60 seconds. Prevents back-to-back fires while you ladder out of a position.
**Example: take-profit watcher.**
```
What you set: Action = buy, cooldown = 60s.
When it fires: After every buy on any chain. The agent watches the new position and posts an alert when it hits +50% or -25%.
```
**Example: realized PnL log.**
```
What you set: Action = sell, cooldown = 30s.
When it fires: After every sell. The agent records entry, exit, hold time, and realized PnL to a log you can pull later.
```
This trigger fires off your own wallet activity, not signals or alpha. To react to alpha calls or group mentions instead, see [Natural Language Trading](/agent-kit/nlp-overview).
## Allow API calls
Turning this on lets you invoke the agent from outside Shuriken. Same agent, same task prompt, same tools. The fire signal comes from your own webhook, script, or MCP client.
### REST
`POST /api/v2/agents/{agentId}/invoke`. Send a Bearer token from a key with the `invoke:agent` scope, a JSON body with the prompt, and an optional `await_result` flag. The optional `Idempotency-Key` header makes a retry safe: same key, same response, no duplicate session.
```bash theme={null}
curl -X POST https://api.shuriken.trade/api/v2/agents/$AGENT_ID/invoke \
-H "Authorization: Bearer $SHURIKEN_AGENT_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $(uuidgen)" \
-d '{
"prompt": "Run my morning briefing now",
"await_result": true
}'
```
To check on a session you started without awaiting, call `GET /api/v2/agents/sessions/{sessionId}/status`.
### MCP
The same surface is exposed as MCP tools to any MCP client, including Claude Desktop, Cursor, and Windsurf. Both tools require a key with the `invoke:agent` scope.
```ts theme={null}
// From a Claude Desktop or Cursor session connected to Shuriken MCP
await invoke_agent({
agent_id: "ag_abc123",
prompt: "Run a rug check on this contract: ",
await_result: true,
})
// Poll a long-running session
await get_agent_invocation_status({
session_id: "sess_xyz789",
})
```
For keys that should *only* fire agents and nothing else, pick the **agent-invoker** playbook when you create the key. It bundles `invoke:agent` and the read scopes the agent needs to start, with no trade scope of its own.
### Rate limit
Set `max_per_minute` on the trigger (default 10). The endpoint returns `429` once you cross it. Useful for keys you embed in webhooks where a stuck loop could otherwise burn through your credit.
## Combining triggers
An agent can carry a schedule, a trade trigger, and an API trigger at the same time.
A research agent might run every morning on a schedule, fire after every buy you make for a quick post-trade sanity check, and also be callable on demand from your Claude Desktop session when you want a one-off. Each fire is its own session with its own transcript.
## Testing a trigger
The agent modal has a "Run" button in the top bar. It fires the agent once with a custom prompt, ignoring all triggers. Use it to sanity-check the task prompt before you turn triggers on. The session shows up in the same run history as a real fire.
## Get started
Concept, run lifecycle, Stop button, credits and billing.
The full list of scopes, plus the per-trade and daily limits the agent runs under.
# Natural Language Trading
Source: https://docs.shuriken.trade/agent-kit/nlp-overview
Talk to Shuriken in plain English from Telegram. No commands to memorize. Just ask.
Shuriken understands plain English. Instead of navigating the terminal or memorizing bot commands, you can just type what you want - and Shuriken figures out the rest.
The first interface is Telegram. Message [@shuriken\_trade\_bot](https://t.me/shuriken_trade_bot) like you'd message a friend and it handles everything: checking balances, pulling trending tokens, executing trades, querying alpha feeds, and more - across Solana, Base, BSC, and Monad.
No code, no commands, no configuration files. Just open Telegram and start talking.
## What you can do
Buy and sell tokens on Solana, Base, BSC, and Monad using plain English or crypto slang. "ape 2 SOL into WIF" works just as well as "buy \$200 of BONK".
Ask about your balance, positions, or PnL for any token you're holding across all your wallets.
Get price, market cap, 24h volume, and liquidity for any token - just name it or paste an address.
See what's trending on X, what tokens your connected groups are calling, and who's talking about what.
Not sure what to ask? Type "what can you do?" and the bot will tell you exactly what it can help with based on your key's permissions.
## Example conversations
Here's what real sessions look like. The bot responds in real-time - it updates its message as it works, so you see progress immediately.
**Token lookup:**
```
You: whats bonk
Shuriken: π BONK (Bonk)
β Price: $0.00001234
β Market Cap: $872M
β 24h Volume: $45.2M
β 24h Change: +12.3%
β Address: DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263
```
**Buy (executes immediately - no confirmation step):**
```
You: ape 2 sol into wif
Shuriken: β‘ Buying WIF...
β
Bought 145.12 WIF for 2.0 SOL ($339.78)
π Tx: 4xK9...def
```
**Check a position:**
```
You: how much bonk do I have
Shuriken: πΌ Your BONK Position
β Balance: 16,198,332 BONK
β Value: $199.89
β Avg Entry: $0.00001150
β Current: $0.00001234
β PnL: +7.3% (+$13.51)
β Wallet: Main Wallet
```
**Recent alpha:**
```
You: what's being called rn
Shuriken: π₯ Recent Alpha Calls
β WIF β called by @CryptoGems (2m ago)
β POPCAT β called by Alpha Discord (5m ago)
β BONK β called by @SolanaAlpha (12m ago)
β JUP β called by Degen TG (18m ago)
```
**Sell:**
```
You: dump all my wif
Shuriken: β‘ Selling all WIF...
β
Sold 145.12 WIF for 2.01 SOL ($341.22)
β PnL: +0.4% (+$1.44)
π Tx: 9aR3...jkl
```
## Talk like a trader
You don't need to use formal language. Shuriken understands crypto slang.
| Slang | What it means |
| ------------------------------- | --------------------------------------- |
| "ape", "ape in", "ape into" | Buy (aggressive) |
| "dump", "nuke", "exit" | Sell |
| "bags" | Your holdings / positions |
| "all in" | Buy with full balance |
| "take profit" / "tp" | Sell at profit |
| "cut losses" / "stop loss" | Sell at a loss |
| "flip" | Quick buy and sell |
| "5 sol of X" | Buy X token using 5 SOL as input |
| "what's trending" / "KOL picks" | What's being called on X |
| "recent alpha" | Latest calls from your connected groups |
## How trading works
Trades execute immediately - there is no confirmation step. When you say "buy \$500 of BONK", Shuriken resolves the token, gets a quote, and executes. You'll see the result in seconds.
Your agent key's trading limits are the safety net. If a trade would exceed your per-trade or daily dollar limit, Shuriken rejects it and tells you why.
**Example - hitting a limit:**
```
You: buy $50000 of bonk
Shuriken: β Trade rejected: exceeds your per-trade limit ($5,000 max).
π‘ Try a smaller amount, or check your limits with "my usage".
```
**Example - missing amount:**
```
You: buy bonk
Shuriken: βΉοΈ Missing trade amount.
π‘ Send a complete command, e.g. "buy $500 of BONK"
```
Trades move real funds and execute immediately with no confirmation step. Make sure your agent key has appropriate per-trade and daily limits set before enabling Execute Trades. See [Permissions & Safety](/agent-kit/permissions).
## What's under the hood
Your agent key controls everything. The same permissions and limits that apply to MCP connections (Cursor, Claude) apply here. A read-only key means the bot can look things up but can't trade. A trading key means it can execute - but only within the dollar limits you set.
**Your private keys are never exposed.** All limits are enforced server-side before anything executes.
## Coming soon
Telegram is the first surface. The same NLP layer will power:
* **X (Twitter)** - `@mention` [@ShurikenTrade](https://x.com/ShurikenTrade) in a tweet to execute trades or get info
* **Discord** - Chat with Shuriken in trading-focused servers and DMs
* **Terminal** - Ask questions about any token directly inside the Shuriken terminal
Every new platform uses the same tools, the same guardrails, and the same key scoping.
## Get started
Enable Telegram on your agent key and start chatting in 2 minutes.
Understand your daily budget, tiers, and usage dashboard.
# Telegram Setup
Source: https://docs.shuriken.trade/agent-kit/nlp-telegram
Enable natural language trading in Telegram in two steps: create a Telegram-enabled agent key, then start chatting.
To use Shuriken's NLP in Telegram, you need one thing: an agent key with the **Telegram** option enabled. Once that's in place, open [@shuriken\_trade\_bot](https://t.me/shuriken_trade_bot) and start typing - no commands, no configuration, no API keys to paste.
## Step 1: Create a Telegram-enabled agent key
Go to [app.shuriken.trade](https://app.shuriken.trade), click your **profile icon** in the top-right corner, and select **Agent Keys**.
Click **+ New Agent** to open the key creation modal.
Select the permissions you want. For full NLP trading, you'll typically want:
* **Account access** - read your profile and trade settings
* **Read alpha** - access token mentions from your connected sources
* **Read tokens** - look up prices, stats, and market data
* **Read wallets** - view your wallet addresses
* **Read balances** - view your holdings and portfolio value
* **Get quotes** - check trade prices without executing
* **Execute trades** - actually place trades (optional - only enable if you want the bot to trade for you)
**Execute trades** moves real funds and trades happen immediately with no confirmation step. Only enable it if you're comfortable with that. Set conservative per-trade and daily dollar limits when you first turn it on.
Scroll down to the **Shuriken AI** section at the bottom of the modal. Check the **Telegram** box.
If you already have a Telegram account linked to Shuriken, you'll see a confirmation that your account is connected. The key will be tied to that Telegram account automatically.
Click **Create Key**. Your key is now active and Telegram is enabled.
## Step 2: Start chatting
Open [@shuriken\_trade\_bot](https://t.me/shuriken_trade_bot) on Telegram and start a conversation.
Write what you want in plain English (or crypto slang). Some things to try:
* "whats trending"
* "what's my balance"
* "how much BONK do I have"
* "ape 0.5 sol into WIF"
* "dump all my BONK"
* "what's the price of SOL"
* "show my positions"
* "recent alpha"
The bot links your Telegram account to your Shuriken account automatically - no login, no code to paste, no API keys.
## What if the bot says you don't have a key?
If you message the bot before creating a Telegram-enabled key, you'll see this:
Tap **Enable one in the Shuriken Terminal** and it'll take you straight to Agent Keys to set one up.
## Understanding the responses
The bot uses a consistent format so responses are easy to scan at a glance:
```
π Token info
πΌ Position / portfolio
β‘ Trade in progress
β
Trade complete
β Error / rejected
βΉοΈ Missing information
π‘ Hint / suggestion
```
When something goes wrong, the bot tells you exactly what happened and what to do next:
```
You: buy $50000 of bonk
Shuriken: β Trade rejected: exceeds your per-trade limit ($5,000 max).
π‘ Try a smaller amount, or check your limits with "my usage".
```
If you forget to include an amount for a trade, the bot asks you to resend a complete command rather than guessing:
```
You: buy bonk
Shuriken: βΉοΈ Missing trade amount.
π‘ Send a complete command, e.g. "buy $500 of BONK"
```
## Confirming it's set up
Once your key is created with Telegram enabled, you'll see **Telegram** appear in the Platforms column on the Agent Keys page. Keys without Telegram enabled show a dash in that column.
## Managing your key
You can view, pause, or revoke your key at any time from [app.shuriken.trade/agents](https://app.shuriken.trade/agents).
* **Pause** - temporarily disables the bot without deleting the key
* **Revoke** - permanently removes access (the bot stops working immediately)
You can have multiple keys. For example, a read-only key for checking prices and a separate trading key with strict limits. The bot uses whichever key has Telegram enabled.
## Next steps
See how your daily budget works and which tier you're on.
Learn what each permission unlocks and how to set safe trading limits.
# Usage & Billing
Source: https://docs.shuriken.trade/agent-kit/nlp-usage
Every NLP request has a small LLM cost. Your daily budget is determined by your trading volume on Shuriken.
Every message you send to the NLP layer - whether from Telegram or any future surface - has a small associated cost from the underlying language model. Shuriken covers this cost up to your daily limit, which scales with how much you trade.
## How your budget works
New users start on **Tier 0** with a one-time \$5 lifetime allowance. That's enough to try the feature and see how it works. To unlock a renewable daily budget, you need to hit \$1,000 in trading volume on Shuriken - which moves you to Tier 1.
From Tier 1 onward, your budget resets every day at midnight UTC.
| Tier | Trading Volume Required | NLP Budget | Reset |
| -------------------- | ----------------------- | ------------ | -------------------------- |
| **Tier 0** (default) | None | \$5 lifetime | Never - one-time allowance |
| **Tier 1** | \$1,000+ | \$1/day | Daily at midnight UTC |
| **Tier 2** | \$10,000+ | \$5/day | Daily at midnight UTC |
| **Tier 3** | \$50,000+ | \$25/day | Daily at midnight UTC |
| **Tier 4** | \$100,000+ | \$50/day | Daily at midnight UTC |
Tier 0 is a lifetime budget - once you've used your \$5, you won't be able to send more NLP messages until you reach \$1,000 in trading volume. Trading volume is cumulative and calculated across all your wallets.
## Viewing your usage
Everything is visible by clicking **AI Usage** in the bottom-right corner of the Agent Keys page.
### What you can see
* **Tier and budget** - your current tier, how much of your budget you've used, and how much trading volume you need to reach the next tier
* **All-time stats** - total requests made, total tokens consumed, and total cost
* **30-day usage chart** - a bar chart showing your spend per day over the last month
* **Activity log** - every recent request with the timestamp, which surface it came from (Terminal, Telegram, etc.), the action taken, cost, and status
## Staying within your budget
Each request costs a fraction of a cent in most cases - simple queries like checking a balance or fetching trending tokens are very cheap. More complex multi-step requests (e.g., "research this token and give me a full breakdown") cost more because they involve more tool calls and a longer model response.
If you're approaching your daily limit, stick to simple, direct questions. "What's the price of BONK?" is much cheaper than "Give me a full analysis of BONK with alpha history, on-chain stats, and a trading recommendation."
## Frequently asked questions
The bot will let you know you've hit your daily limit. You won't be charged anything extra - requests simply won't be processed until your budget resets at midnight UTC (or, for Tier 0 users, until you reach \$1,000 in volume).
No. Unused budget does not accumulate. Each day starts fresh at your tier's daily limit.
Volume is calculated from trades executed through Shuriken - including the terminal, Telegram bot, browser extension, and MCP agent. It's cumulative and doesn't reset.
Yes - your current tier, remaining daily budget, and volume progress toward the next tier are all shown on the /agents page in the terminal.
# AI Agent Kit
Source: https://docs.shuriken.trade/agent-kit/overview
Your agent catches alpha and trades for you while you're away. You set the execution limits. Set it up in 60 seconds.
Alpha calls don't wait for you to be online. Connect an AI agent to your Shuriken account and let it catch the opportunities you'd miss - while you set the rules.
If you can type a message, you can use an agent. No code, no server, no monthly fee. You'll be set up in about 60 seconds.
Your private keys are impossible to expose. You set the execution limits - how much it can spend, which wallets it can touch - and Shuriken enforces them server-side. The agent can't override them.
## Two ways to use Shuriken AI
Message [@shuriken\_trade\_bot](https://t.me/shuriken_trade_bot) on Telegram in plain English. "Whats trending", "buy 1 SOL", "show my balance" - no commands to memorize.
Connect external AI tools like Cursor, Claude Desktop, or Windsurf to your Shuriken account via the Model Context Protocol.
Both use the same agent key system and the same guardrails. Pick one or use both.
## What can an AI agent do?
Calls that land while you're asleep or away from your desk don't have to go cold. Your agent catches them and can act within the limits you set.
Ask for any token's price, market cap, volume, and liquidity. No dashboards, no tabs - just ask.
Your agent can buy and sell tokens on Solana directly from a chat - with dollar limits, slippage caps, and wallet restrictions you define upfront.
Every limit is enforced server-side before the agent even starts. It can't override what you don't allow - no matter what.
## How it works
The Agent Kit uses **MCP** (Model Context Protocol) - an open standard that lets AI tools securely connect to external services. You don't need to understand MCP to use it. Here's the simple version:
1. **You create an Agent Key** on Shuriken - takes about 30 seconds. Pick a preset or build a custom key with the exact [permissions](/agent-kit/permissions) you want.
2. **You paste the key** into your AI tool's config file (we'll walk you through it - takes another 30 seconds)
3. **You start chatting** - your AI assistant now has access to Shuriken's tools
4. **You monitor activity** - see exactly what your agent is doing in real-time from the [Agent Keys dashboard](https://app.shuriken.trade/agents)
The guardrails are set before your agent is even created. You define exactly what it can spend, which wallets it can touch, and how far it can go - and Shuriken enforces all of it server-side. The agent can't override any of it, no matter what.
Your Agent Key controls exactly what the AI can and can't do. A read-only key can check prices but can't touch your wallet. A trading key can execute trades but only within the dollar limits you set. You're always in control.
## What people are using it for
* **Morning briefing:** "What tokens were called in my Discord overnight? Filter by market cap under \$1M."
* **Due diligence:** "I'm looking at this token - check the liquidity, holder distribution, and recent volume. Worth a position?"
* **Quick research:** "Look up the stats for BONK - price, volume, liquidity."
* **Portfolio check:** "What are my top positions by PnL?"
* **Hands-free trading:** "Buy 0.1 SOL worth of GRIFFAIN" - then check back later to see how it went.
* **Filtering noise:** "Show me calls with at least 3 mentions in the last 24 hours"
## Get started
Pick your AI tool and you'll be connected in under 2 minutes:
Open-source AI agent. Chat via WhatsApp, Telegram, Discord, or the web UI.
Best for developers and power users. Full IDE with built-in AI.
Anthropic's desktop app. Great for conversational research and trading.
AI-powered IDE by Codeium. Similar setup to Cursor.
Using a different tool? Follow the generic setup guide.
New to this? Start by [creating an Agent Key](/agent-kit/create-agent-key) first, then come back and pick your AI tool.
# Permissions & Safety
Source: https://docs.shuriken.trade/agent-kit/permissions
Understand what each permission unlocks, how trading limits work, and how to keep your funds safe.
The guardrails are set before your agent is even created. You define exactly what it can do, what it can spend, and which wallets it can touch - and Shuriken enforces all of it server-side. The agent can't override any of it, no matter what. This page explains each permission in detail, how trading limits work, and recommended setups for different use cases.
## Permissions overview
There are six permissions you can toggle when creating a custom Agent Key. Each one unlocks a specific set of capabilities.
Permissions are enforced on the server side. Even if an AI agent tries to bypass its restrictions, Shuriken's server will reject any unauthorized requests. Your funds are protected regardless of what the AI tries to do.
### Read Wallets
View your connected wallet addresses and names.
| What the agent can do | Example prompt |
| ------------------------------- | ----------------------------------- |
| List all your wallets | "What wallets do I have connected?" |
| See wallet addresses and chains | "What's my Solana wallet address?" |
### Read Balances
View token balances, holdings, and profit/loss data.
| What the agent can do | Example prompt |
| ------------------------------------------------------- | ----------------------------- |
| Check native balance (SOL, ETH) | "How much SOL do I have?" |
| See all token holdings with USD values | "Show me my portfolio" |
| View PnL per position (cost basis, realized/unrealized) | "What's my PnL on GRIFFAIN?" |
| Check a specific token position | "How much BONK am I holding?" |
### Read Alpha
Access token mentions from your connected Discord/Telegram groups and trending calls from X (Twitter).
| What the agent can do | Example prompt |
| ----------------------------------------- | ---------------------------------------------- |
| See your connected alpha sources | "What Discord servers am I tracking?" |
| View recent token calls from your groups | "What tokens were called today?" |
| See globally trending KOL mentions from X | "What's trending on Crypto Twitter right now?" |
| Get detailed mention history for a token | "Who called ARC and when?" |
### Read Tokens
Look up token metadata, market data, and trading statistics.
| What the agent can do | Example prompt |
| ------------------------------------------------------------ | ------------------------------------ |
| Search tokens by name, symbol, or address | "Find the token called GRIFFAIN" |
| Get price, market cap, and liquidity | "What's the market cap of BONK?" |
| View trading volume and transaction counts (5m, 1h, 6h, 24h) | "Show me 24h volume for SOL" |
| Check number of buyers vs sellers | "Is PEPE seeing more buys or sells?" |
### Get Quotes
Create trade plans and get price quotes without actually executing. Useful for research and price checking.
| What the agent can do | Example prompt |
| --------------------------------- | ------------------------------------------------------- |
| Get a quote for a potential trade | "How much GRIFFAIN would I get for 0.1 SOL?" |
| See the estimated output in USD | "What would it cost to buy \$10 worth of BONK?" |
| View slippage and price impact | "What's the price impact on a 1 SOL buy of this token?" |
| Check remaining daily limits | "How much of my daily budget have I used?" |
The Get Quotes permission gives the agent `plan_trade` access. This creates a trade plan with a 5-minute expiry, but the agent **cannot execute it** without the Execute Trades permission. Think of it like window shopping - you can check the price tag but can't buy.
### Execute Trades
Actually move real funds - buy and sell tokens from your wallet.
| What the agent can do | Example prompt |
| --------------------- | ------------------------------- |
| Buy tokens with SOL | "Buy 0.1 SOL worth of GRIFFAIN" |
| Sell token holdings | "Sell 50% of my BONK position" |
| Check trade status | "Did my last trade go through?" |
This is the only permission that can move money. When enabled, additional safety controls (trading limits) become available. We strongly recommend setting conservative limits, especially when starting out.
## Trading limits
When you enable **Execute Trades**, you get access to fine-grained controls that cap what your agent can do. These are enforced server-side - the agent cannot override them.
### Buying limits
| Setting | What it controls |
| ---------------------- | ----------------------------------------------------------- |
| **Max per day (\$)** | Total USD your agent can spend on purchases in a single day |
| **Max per trade (\$)** | Most your agent can spend on a single buy order |
### Selling limits
| Setting | What it controls |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Max per day (\$)** | Total USD your agent can sell in a single day |
| **Max per trade (\$)** | Most your agent can sell in a single trade |
| **Max sell size (%)** | Largest percentage of any token position the agent can sell at once (e.g., 50% means it can never dump an entire position in one trade) |
### Execution & safety
| Setting | What it controls |
| -------------------- | ------------------------------------------------------------------------------------------------------------- |
| **Trades per hour** | Maximum number of trades the agent can execute per hour |
| **Trades per day** | Maximum number of trades per day |
| **Concurrent** | How many trades can be in-flight at the same time |
| **Max slippage (%)** | Highest slippage tolerance the agent can use. Prevents the agent from accepting bad prices on illiquid tokens |
### Additional options
| Setting | What it controls |
| --------------------- | ------------------------------------------------------------------------ |
| **Custom gas fees** | Allow the agent to set priority fees for faster transaction confirmation |
| **MEV bribes (Jito)** | Allow the agent to use Jito tips for MEV protection on Solana |
## How the two-step trading flow works
Trading always happens in two steps. This is a safety feature - the agent must get a quote before it can execute.
**Step 1: Plan** - The agent calls `plan_trade` to get a quote. The response includes:
* Exact input and output amounts
* Estimated USD value
* Slippage and price impact
* A plan ID that expires in 5 minutes
* A policy check showing remaining limits (e.g., "$8.64 / $500.00 daily buy")
**Step 2: Execute** - The agent calls `execute_trade` with the plan ID. The server validates the plan hasn't expired and all limits are still within bounds, then submits the transaction.
If a plan expires (after 5 minutes), the agent must create a new one. This prevents stale quotes from being executed at outdated prices.
## Recommended setups
Here are some common configurations depending on what you want your agent to do:
**Permissions:** Read Alpha, Read Tokens
**Use case:** You want the AI to help you research tokens and monitor alpha calls without seeing your wallet or having any trading access.
**Risk level:** None - the agent can't see or touch your funds.
**Permissions:** Read Wallets, Read Balances, Read Tokens, Get Quotes
**Use case:** You want to ask the AI about your holdings, check PnL, and get trade quotes without giving it the ability to execute.
**Risk level:** None - the agent can see your portfolio but can't make any changes.
**Permissions:** All six enabled
**Trading limits:**
* Max \$10 per trade
* Max \$50 per day
* Max sell size: 25%
* Max slippage: 5%
**Use case:** You want the AI to be able to trade small amounts while you learn how it works.
**Risk level:** Low - even if something goes wrong, exposure is capped at \$50/day.
**Permissions:** All six enabled
**Trading limits:**
* Max \$100 per trade
* Max \$500 per day
* Max sell size: 100%
* Trades per hour: 20
**Use case:** You're comfortable with the agent trading and want it to have enough room to act on opportunities.
**Risk level:** Medium - higher limits mean more exposure if the agent makes a bad call.
## Security best practices
* **Start read-only.** Create a read-only key first to test the connection and get comfortable before enabling trading.
* **Use separate keys.** Create one key for research and a different key for trading. This way you can revoke trading access without losing your research setup.
* **Set conservative limits.** Start with low dollar limits and increase them only after you're confident in your setup.
* **Review activity regularly.** Check the [Agent Keys dashboard](https://app.shuriken.trade/agents) to see every action your agent takes in real-time. If anything looks off, pause or revoke the key immediately.
* **Revoke unused keys.** If you're not using a key anymore, revoke it. You can always create a new one.
* **Never share your key.** Your Agent Key is like a password. Don't post it publicly, commit it to Git, or share it in Discord.
## Next steps
Ready to connect your agent? Pick your AI tool:
# Authentication
Source: https://docs.shuriken.trade/api-reference/authentication
Authenticate with the Shuriken API using Bearer tokens.
Every Shuriken API request requires a Bearer token in the `Authorization` header. Your API key controls what the caller can access - from read-only token lookups to full trade execution.
## Getting your API key
Create an Agent Key from the Shuriken Terminal. Each key comes with configurable permissions and spending limits enforced server-side.
Click your **profile icon** in the top-right corner of the Terminal, then select **Agent Keys**.
Click **+ New Agent** and choose a template or create a custom key with the exact permissions you need.
Copy the key immediately - you won't be able to see it again.
See the full [Create an Agent Key](/agent-kit/create-agent-key) guide for templates, custom permissions, and trading limits.
## Using your key
Include the key as a Bearer token in the `Authorization` header on every request:
```bash theme={null}
curl -X GET "https://api.shuriken.trade/api/v2/account/me" \
-H "Authorization: Bearer YOUR_API_KEY"
```
```python Python theme={null}
import requests
headers = {"Authorization": "Bearer YOUR_API_KEY"}
response = requests.get(
"https://api.shuriken.trade/api/v2/account/me",
headers=headers,
)
```
```javascript JavaScript theme={null}
const response = await fetch(
"https://api.shuriken.trade/api/v2/account/me",
{ headers: { Authorization: "Bearer YOUR_API_KEY" } }
);
```
## Authentication errors
If your key is missing, invalid, or expired, the API returns a `401`:
```json theme={null}
{
"error": {
"code": "UNAUTHORIZED",
"message": "Invalid or expired API key"
},
"requestId": "req_abc123"
}
```
Some endpoints require specific permissions. If your key lacks the required scope, you'll get a `403`.
## Security best practices
* Store keys in environment variables, never in source code
* Rotate keys periodically from the [Agent Keys dashboard](https://app.shuriken.trade/agents)
* Use the minimum permissions needed for your use case
* Monitor key activity and usage via `GET /api/v2/account/usage`
API keys grant access to your Shuriken account. Never share them publicly or commit them to version control.
# CLI
Source: https://docs.shuriken.trade/api-reference/cli
Install and use the Shuriken command-line client for the v2 developer surface.
The Shuriken CLI is a thin Rust client over the same REST surface used by the SDKs. It's built for quick lookups, scripting, and testing without writing SDK code.
The CLI only supports HTTP endpoints. For real-time streams use the [WebSocket API](/api-reference/websocket/overview) directly or one of the [SDKs](/api-reference/introduction#sdks).
## Install
```bash theme={null}
curl -fsSL https://cdn.shuriken.trade/shuriken-cli/install.sh | sh
```
The installer drops a single `shuriken` binary in `~/.local/bin`. Make sure that directory is on your `PATH`.
### Installer environment variables
| Variable | Purpose | Default |
| ---------------------------- | -------------------------------------------------------- | ----------------------------------------- |
| `SHURIKEN_VERSION` | Release channel or version to install | `latest` |
| `SHURIKEN_INSTALL_DIR` | Directory where the `shuriken` symlink is created | `~/.local/bin` |
| `SHURIKEN_DOWNLOAD_BASE_URL` | Override the CDN base URL (mirrors or local smoke tests) | `https://cdn.shuriken.trade/shuriken-cli` |
| `NO_COLOR` | Disable colored installer output | unset |
Pass them on the same line as `sh`:
```bash theme={null}
curl -fsSL https://cdn.shuriken.trade/shuriken-cli/install.sh | SHURIKEN_VERSION=v0.3.2 sh
curl -fsSL https://cdn.shuriken.trade/shuriken-cli/install.sh | SHURIKEN_INSTALL_DIR="$HOME/bin" sh
```
## Authentication
The CLI reads your API key from a config file or `SHURIKEN_API_KEY` environment variable. Create an [Agent Key](/agent-kit/create-agent-key) from the Terminal first, then:
```bash theme={null}
export SHURIKEN_API_KEY="your_api_key"
shuriken account me
```
## Updating
Installer-managed installs support channel-aware update detection and in-place updates:
```bash theme={null}
shuriken update check
shuriken update check --output json
shuriken update apply
```
Pinned installs (`SHURIKEN_VERSION=vX.Y.Z`) stay pinned. Re-run the installer to move them to `latest` or another explicit version.
## Manual verification
To verify a release tarball manually, download the tarball plus checksum for your platform:
```bash theme={null}
curl -fsSLO https://cdn.shuriken.trade/shuriken-cli/releases/v0.3.2/shuriken-darwin-arm64.tar.gz
curl -fsSLO https://cdn.shuriken.trade/shuriken-cli/releases/v0.3.2/shuriken-darwin-arm64.tar.gz.sha256
shasum -a 256 -c shuriken-darwin-arm64.tar.gz.sha256
tar -xzf shuriken-darwin-arm64.tar.gz
./shuriken --version
```
# Enable Multisend
Source: https://docs.shuriken.trade/api-reference/endpoint/account/enable-multisend
POST /api/v2/account/wallets/{walletId}/enable-multisend
# Get User Profile
Source: https://docs.shuriken.trade/api-reference/endpoint/account/get-me
GET /api/v2/account/me
# Get User Settings
Source: https://docs.shuriken.trade/api-reference/endpoint/account/get-settings
GET /api/v2/account/settings
# Get API Key Usage
Source: https://docs.shuriken.trade/api-reference/endpoint/account/get-usage
GET /api/v2/account/usage
No scope check required β any valid API key can introspect its own usage.
This is intentional: usage/quota info is a property of the key itself.
# List Wallets
Source: https://docs.shuriken.trade/api-reference/endpoint/account/get-wallets
GET /api/v2/account/wallets
# Patch Settings
Source: https://docs.shuriken.trade/api-reference/endpoint/account/patch-settings
PATCH /api/v2/account/settings
Only the fields present in the request body are updated; everything else
is preserved from the current settings.
# Update User Settings
Source: https://docs.shuriken.trade/api-reference/endpoint/account/update-settings
PUT /api/v2/account/settings
# Get Alpha Call Context for a Token
Source: https://docs.shuriken.trade/api-reference/endpoint/alpha/call-context
GET /api/v2/alpha/tokens/{tokenAddress}/call-context
# List Global Alpha Calls (X/Twitter)
Source: https://docs.shuriken.trade/api-reference/endpoint/alpha/global-calls
GET /api/v2/alpha/global-calls
# Get Token Mention History
Source: https://docs.shuriken.trade/api-reference/endpoint/alpha/mentions
GET /api/v2/alpha/tokens/{tokenAddress}/mentions
# List Recent Alpha Calls
Source: https://docs.shuriken.trade/api-reference/endpoint/alpha/recent-calls
GET /api/v2/alpha/recent-calls
# List Connected Alpha Sources
Source: https://docs.shuriken.trade/api-reference/endpoint/alpha/sources
GET /api/v2/alpha/sources
# Batch Modify Orders
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/batch-modify-orders
PATCH /api/v2/perp/orders
# Cancel Order
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/cancel-order
DELETE /api/v2/perp/order
# Close Position
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/close-position
POST /api/v2/perp/position/close
# Get Perp Account
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-account
GET /api/v2/perp/account
# Get Fee Schedule
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-fees
GET /api/v2/perp/fees
# Get Trade Fills
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-fills
GET /api/v2/perp/fills
# Get Funding History
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-funding
GET /api/v2/perp/funding
# Get Market
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-market
GET /api/v2/perp/markets/{coin}
# List Markets
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-markets
GET /api/v2/perp/markets
# Get Open Orders
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-orders
GET /api/v2/perp/orders
# Get Positions
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/get-positions
GET /api/v2/perp/positions
# Modify Order
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/modify-order
PATCH /api/v2/perp/order
# Place Order
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/place-order
POST /api/v2/perp/order
# Update Leverage
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/update-leverage
POST /api/v2/perp/leverage
# Update Margin
Source: https://docs.shuriken.trade/api-reference/endpoint/perp/update-margin
POST /api/v2/perp/position/margin
# Get Portfolio Balances
Source: https://docs.shuriken.trade/api-reference/endpoint/portfolio/get-balances
GET /api/v2/portfolio/balances
# Get Trade History
Source: https://docs.shuriken.trade/api-reference/endpoint/portfolio/get-history
GET /api/v2/portfolio/history
# Get Portfolio PnL
Source: https://docs.shuriken.trade/api-reference/endpoint/portfolio/get-pnl
GET /api/v2/portfolio/pnl
# Get Positions
Source: https://docs.shuriken.trade/api-reference/endpoint/portfolio/get-positions
GET /api/v2/portfolio/positions
# Create Trade Suggestion
Source: https://docs.shuriken.trade/api-reference/endpoint/suggestions/create-suggestion
POST /api/v2/agents/suggestions
# List Trade Suggestions
Source: https://docs.shuriken.trade/api-reference/endpoint/suggestions/list-suggestions
GET /api/v2/agents/suggestions
# Build Unsigned Transaction
Source: https://docs.shuriken.trade/api-reference/endpoint/swap/create-transaction
POST /api/v2/swap/transaction
Quotes with chain-appropriate resolvers, builds an unsigned transaction,
and returns it for the caller to sign locally. SVM returns base64
VersionedTransaction; EVM returns EIP-1559 envelope(s) with optional
approval transaction.
# Execute Swap
Source: https://docs.shuriken.trade/api-reference/endpoint/swap/execute
POST /api/v2/swap/execute
Direct execution flow: validates wallet, fetches token metadata,
builds task request, and submits to task service. No plan_storage dependency.
# Check ERC-20 Allowance
Source: https://docs.shuriken.trade/api-reference/endpoint/swap/get-allowance
GET /api/v2/swap/approve/allowance
# Get Swap Quote
Source: https://docs.shuriken.trade/api-reference/endpoint/swap/get-quote
GET /api/v2/swap/quote
# Get Router Address
Source: https://docs.shuriken.trade/api-reference/endpoint/swap/get-spender
GET /api/v2/swap/approve/spender
# Submit Signed Transaction
Source: https://docs.shuriken.trade/api-reference/endpoint/swap/submit
POST /api/v2/swap/submit
Accepts a user-signed transaction, registers it for monitoring in
task-service, and submits it through Shuriken's RPCs for better landing.
Returns a taskId for status polling via `/status/:taskId`.
# Get Task Status
Source: https://docs.shuriken.trade/api-reference/endpoint/tasks/get-status
GET /api/v2/tasks/{taskId}
# Batch Get Tokens
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/batch
POST /api/v2/tokens/batch
# Get Token Pools
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/get-pools
GET /api/v2/tokens/{tokenId}/pools
# Get Token Price
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/get-price
GET /api/v2/tokens/{tokenId}/price
# Get Price Chart
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/get-price-chart
GET /api/v2/tokens/{tokenId}/price/chart
# Get Token Stats
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/get-stats
GET /api/v2/tokens/{tokenId}/stats
# Get Token by ID
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/get-token
GET /api/v2/tokens/{tokenId}
# Search Tokens
Source: https://docs.shuriken.trade/api-reference/endpoint/tokens/search
GET /api/v2/tokens/search
# Create Trigger Order
Source: https://docs.shuriken.trade/api-reference/endpoint/trigger/create-order
POST /api/v2/trigger/order
# Cancel Trigger Order
Source: https://docs.shuriken.trade/api-reference/endpoint/trigger/delete-order
DELETE /api/v2/trigger/order/{orderId}
# Get Trigger Order
Source: https://docs.shuriken.trade/api-reference/endpoint/trigger/get-order
GET /api/v2/trigger/order/{orderId}
# List Trigger Orders
Source: https://docs.shuriken.trade/api-reference/endpoint/trigger/list-orders
GET /api/v2/trigger/orders
# Add Wallets to Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/add-wallets
POST /api/v2/wallet-groups/{groupId}/wallets
# Create Wallet Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/create-group
POST /api/v2/wallet-groups
# Create Group with Fresh Wallets
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/create-with-wallets
POST /api/v2/wallet-groups/with-wallets
# Delete Wallet Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/delete-group
DELETE /api/v2/wallet-groups/{groupId}
# Get Wallet Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/get-group
GET /api/v2/wallet-groups/{groupId}
# List Wallet Groups
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/list-groups
GET /api/v2/wallet-groups
# Move Wallet Between Groups
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/move-wallet
POST /api/v2/wallets/{walletId}/move
# Remove Wallets from Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/remove-wallets
DELETE /api/v2/wallet-groups/{groupId}/wallets
# Reorder Wallets in Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/reorder-wallets
PUT /api/v2/wallet-groups/{groupId}/wallets/order
# Rename Wallet Group
Source: https://docs.shuriken.trade/api-reference/endpoint/wallet-groups/update-group
PATCH /api/v2/wallet-groups/{groupId}
# Errors
Source: https://docs.shuriken.trade/api-reference/errors
Standard error format and common error codes for the Shuriken API.
Every error response from the Shuriken API follows a consistent envelope so you can handle failures predictably across all endpoints.
## Error format
```json theme={null}
{
"error": {
"code": "INVALID_PARAMS",
"message": "Amount must be a positive integer string",
"details": null
},
"requestId": "req_abc123"
}
```
| Field | Description |
| --------------- | ------------------------------------------- |
| `error.code` | Machine-readable error code |
| `error.message` | Human-readable explanation |
| `error.details` | Optional additional context (may be `null`) |
| `requestId` | Unique request identifier for debugging |
Always include the `requestId` when contacting support. It lets us trace exactly what happened.
## Common error codes
| HTTP Status | Code | Typical cause |
| ----------- | ---------------- | -------------------------------------------- |
| 400 | `INVALID_PARAMS` | Missing or invalid parameters |
| 400 | `NO_ROUTE` | No swap route found for the given token pair |
| 401 | `UNAUTHORIZED` | Missing, invalid, or expired API key |
| 403 | `FORBIDDEN` | Key lacks the required permission scope |
| 404 | `NOT_FOUND` | Resource does not exist (token, order, etc.) |
| 429 | `RATE_LIMITED` | Too many requests - slow down |
| 500 | `INTERNAL_ERROR` | Something went wrong on our end |
## Rate limiting
When you exceed your rate limit, the API returns a `429` response. Check your current usage and limits at any time:
```bash theme={null}
curl -X GET "https://api.shuriken.trade/api/v2/account/usage" \
-H "Authorization: Bearer YOUR_API_KEY"
```
## Handling errors
Build resilient integrations by checking the HTTP status code and `error.code` field:
```python Python theme={null}
response = requests.post(
"https://api.shuriken.trade/api/v2/swap/execute",
headers=headers,
json=payload,
)
if response.status_code != 200:
error = response.json()
code = error["error"]["code"]
if code == "NO_ROUTE":
# Try a different token pair or adjust amount
pass
elif code == "RATE_LIMITED":
# Back off and retry
pass
else:
print(f"Error {code}: {error['error']['message']}")
```
# API Introduction
Source: https://docs.shuriken.trade/api-reference/introduction
Programmatic access to multi-chain DEX trading. Quote, swap, and manage positions across Solana, Base, BSC, and Monad.
The Shuriken API v2 gives you direct access to the same multi-chain trading engine that powers the Terminal, Telegram Bot, and AI Agent Kit. Build trading bots, automate strategies, or integrate real-time token data into your own tools through REST endpoints and real-time WebSocket streams.
All API requests require a Bearer token. Create an [Agent Key](/agent-kit/create-agent-key) from the Terminal to get started.
## SDKs
The fastest way to get started is with an official SDK. They handle authentication, typed responses, WebSocket connection management, and automatic reconnection β so you can focus on your trading logic instead of protocol details. See the [SDKs page](/api-reference/sdks) for usage snippets and quickstart repos.
REST + WebSocket client with typed events. Install via `npm install @shuriken/sdk-ts`.
Async REST + WebSocket with `futures::Stream` support. Add `shuriken-sdk` to your `Cargo.toml`.
## CLI
A thin command-line client for the same v2 developer surface β useful for quick lookups, scripting, and testing without writing SDK code. HTTP only; WebSocket streams require an SDK or direct connection. The installer drops a single `shuriken` binary in `~/.local/bin` and supports in-place updates via `shuriken update apply`. See the [CLI page](/api-reference/cli) for installer flags, auth, and update details.
```bash theme={null}
curl -fsSL https://cdn.shuriken.trade/shuriken-cli/install.sh | sh
```
Pin a version with `SHURIKEN_VERSION=v0.3.2` or change the install location with `SHURIKEN_INSTALL_DIR="$HOME/bin"`. Pass either as an environment variable on the same line as `sh`.
## Base URL
All endpoints live under a single base URL with version prefix:
```
https://api.shuriken.trade/api/v2
```
## Supported chains
SVM
EVM
EVM
EVM
## Authentication
Every request must include your API key as a Bearer token in the `Authorization` header:
```bash theme={null}
curl -X GET "https://api.shuriken.trade/api/v2/account/me" \
-H "Authorization: Bearer YOUR_API_KEY"
```
Read the full [Authentication guide](/api-reference/authentication) for setup instructions and security best practices.
## Endpoint groups
Manage your profile, wallets, trade settings, and check API key usage.
View token balances, trade history, PnL summaries, and open positions across all chains.
Get quotes, build transactions, execute swaps, and track execution status.
Search tokens, fetch metadata, prices, OHLCV charts, pool data, and trading stats.
Create and manage limit orders and stop-loss triggers based on price, market cap, or liquidity.
Trade perpetual futures with leverage, manage positions, and track fills and funding.
Real-time streams for swaps, balances, pool data, alpha signals, and portfolio updates.
Poll execution status for async operations like swaps and approvals.
## Response format
All successful responses follow the same envelope:
```json theme={null}
{
"data": { ... },
"requestId": "req_abc123",
"pagination": null
}
```
When pagination applies, the `pagination` field includes `page`, `limit`, `hasMore`, and an optional `total`.
Errors use a consistent format too - see the [Errors reference](/api-reference/errors) for details.
Every response includes a `requestId`. Include it when contacting support to speed up debugging.
# SDKs
Source: https://docs.shuriken.trade/api-reference/sdks
Official TypeScript and Rust SDKs for the Shuriken API.
Official SDKs handle authentication, typed responses, WebSocket connection management, and automatic reconnection β so you can focus on your trading logic instead of protocol details.
REST + WebSocket client with typed events. Install via `npm install @shuriken/sdk-ts`.
Async REST + WebSocket with `futures::Stream` support. Add `shuriken-sdk` to your `Cargo.toml`.
## TypeScript
```bash theme={null}
npm install @shuriken/sdk-ts
```
```ts theme={null}
import { createShurikenClient } from '@shuriken/sdk-ts'
const client = createShurikenClient({
apiKey: process.env.SHURIKEN_API_KEY!,
})
const me = await client.account.getMe()
console.log(me.userId, me.displayName)
```
## Rust
```toml theme={null}
[dependencies]
shuriken-sdk = "0.9"
tokio = { version = "1", features = ["full"] }
```
```rust theme={null}
use shuriken_sdk::ShurikenHttpClient;
#[tokio::main]
async fn main() {
let api_key = std::env::var("SHURIKEN_API_KEY").expect("SHURIKEN_API_KEY not set");
let client = ShurikenHttpClient::new(&api_key).unwrap();
let me = client.account().get_me().await.unwrap();
println!("{} {:?}", me.user_id, me.display_name);
}
```
To enable real-time WebSocket streams in the Rust SDK, opt in to the `ws` feature: `shuriken-sdk = { version = "0.9", features = ["ws"] }`.
## Quickstart repos
Each SDK has a companion quickstart repo with 25+ runnable examples covering account lookups, token analytics, swaps, trigger orders, perp trading, WebSocket streams, and composite strategies (snipers, copy traders, hedgers).
`shuriken-quickstart-ts` β examples runnable with `npx tsx`.
`shuriken-quickstart-rs` β examples runnable with `cargo run --example`.
### Running a TypeScript example
```bash theme={null}
git clone https://github.com/ShurikenTrade/shuriken-quickstart-ts.git
cd shuriken-quickstart-ts
npm install
cp .env.example .env # add your SHURIKEN_API_KEY
npx tsx examples/01-account-info.ts
```
### Running a Rust example
```bash theme={null}
git clone https://github.com/ShurikenTrade/shuriken-quickstart-rs.git
cd shuriken-quickstart-rs
cp .env.example .env # add your SHURIKEN_API_KEY
cargo run --example 01_account_info
```
Trading examples (`07`β`09`) default to a `DRY_RUN` mode in the Rust quickstart β set `DRY_RUN=false` in `.env` to send real transactions. The TypeScript versions execute against the live API by default, so review the script and check the amounts before running.
# WebSocket Overview
Source: https://docs.shuriken.trade/api-reference/websocket/overview
Real-time streaming API for live market data, balance updates, and trading signals.
The Shuriken WebSocket API delivers real-time updates for token swaps, balances, pool data, alpha signals, and more. It uses a Pusher-compatible protocol over WebSocket, authenticated with the same API key you use for REST.
WebSocket streams require a Bearer token. Create an [Agent Key](/agent-kit/create-agent-key) from the Terminal to get started.
## SDKs (recommended)
The WebSocket protocol involves session bootstrapping, Pusher-compatible handshakes, and channel authorization. **We strongly recommend using an official SDK** instead of implementing this yourself:
Full WebSocket support with typed events and automatic reconnection.
Async streams via `futures::Stream` with typed payloads and auto-reconnect.
```typescript theme={null}
import { createShurikenClient } from '@shuriken/sdk-ts';
const client = createShurikenClient({ apiKey: 'sk_your_api_key' });
await client.ws.connect();
client.ws.subscribe('svm.token.swaps', {
tokenAddress: 'So11111111111111111111111111111111111111112',
}, (event) => {
console.log('Swap:', event.priceUsd, event.sizeSol);
});
```
```rust theme={null}
use shuriken_sdk::{ShurikenWsClient, streams::{SVM_TOKEN_SWAPS, SvmTokenFilter}};
use futures_util::StreamExt;
#[tokio::main]
async fn main() -> Result<(), Box> {
let mut ws = ShurikenWsClient::new("sk_your_api_key")?;
ws.connect().await?;
let mut sub = ws.subscribe(
SVM_TOKEN_SWAPS,
SvmTokenFilter { token_address: "So11111111111111111111111111111111111111112".into() },
).await?;
while let Some(event) = sub.next().await {
println!("Swap: {:?}", event);
}
ws.disconnect().await;
Ok(())
}
```
## Raw protocol details
The rest of this page describes the underlying WebSocket protocol. You only need this if you're building a custom client without an SDK.
## How it works
There is no static WebSocket URL. The connection details are discovered dynamically through a session bootstrap call to the same REST API:
POST to `/api/v2/ws/session` with the streams you want to subscribe to. The response contains the WebSocket host, port, app key, and resolved subscription channels.
```bash theme={null}
curl -X POST "https://api.shuriken.trade/api/v2/ws/session" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"subscriptions": [{"stream": "svm.token.swaps", "filter": {"tokenAddress": "So11111111111111111111111111111111111111112"}}]}'
```
The response includes a `connection` object with `wsHost`, `wsPort`, `appKey`, and `forceTls` fields.
Construct the WebSocket URL from the session response and connect:
```
wss://{wsHost}:{wsPort}/app/{appKey}?protocol=7
```
Wait for the `pusher:connection_established` message to get your `socket_id`.
For **public** streams, send a `pusher:subscribe` message with the channel name from the session response.
For **presence** streams (authenticated), first authorize via `POST /api/v2/ws/auth` with your `socket_id` and channel name, then subscribe with the returned auth token.
## Stream discovery
Get the full catalog of available streams and their filters at any time:
```bash theme={null}
curl -X GET "https://api.shuriken.trade/api/v2/ws/streams" \
-H "Authorization: Bearer YOUR_API_KEY"
```
See the [Stream Catalog](/api-reference/websocket/streams) for the complete list.
## Stream types
| Type | Auth required | Description |
| ------------ | ---------------------- | --------------------------------------------------------------- |
| **Public** | API key only | Market data streams anyone can subscribe to |
| **Presence** | API key + channel auth | User-specific streams (portfolio, automation, personal signals) |
## Connection states
| State | Description |
| -------------- | ---------------------------------------- |
| `Disconnected` | No active connection |
| `Connecting` | Handshake in progress |
| `Connected` | Ready to subscribe and receive events |
| `Reconnecting` | Connection lost, attempting to reconnect |
| `Failed` | Connection failed permanently |
## Event format
All stream events arrive as JSON with the following structure:
```json theme={null}
{
"event": "update",
"channel": "private-svm.token.swaps.So111...",
"data": { ... }
}
```
The `data` field contains the stream-specific payload described in the [Stream Catalog](/api-reference/websocket/streams).
# Stream Catalog
Source: https://docs.shuriken.trade/api-reference/websocket/streams
All available WebSocket streams with filters and payload descriptions.
All streams emit events with `"event": "update"`. Subscribe using the stream name and required filters via the [session bootstrap](/api-reference/websocket/overview#connection-lifecycle).
## SVM (Solana) streams
| Stream | Filters | Description |
| ------------------------------ | -------------------------- | ---------------------------------------------- |
| `svm.token.swaps` | `tokenAddress` (required) | Real-time swap events for a token |
| `svm.token.poolInfo` | `tokenAddress` (required) | Pool liquidity and info updates |
| `svm.token.balances` | `tokenAddress` (required) | Token-scoped balance updates |
| `svm.token.distributionStats` | `tokenAddress` (required) | Token holder distribution statistics |
| `svm.token.holderStats` | `tokenAddress` (required) | Holder count and concentration stats |
| `svm.wallet.nativeBalance` | `walletAddress` (required) | SOL balance updates for a wallet |
| `svm.wallet.tokenBalances` | `walletAddress` (required) | SPL token balance updates for a wallet |
| `svm.bondingCurve.creations` | none | New bonding curve token launches |
| `svm.bondingCurve.graduations` | none | Tokens graduating from bonding curves to pools |
## EVM streams
| Stream | Filters | Description |
| -------------------------- | ----------------------------------------------- | ----------------------------------------- |
| `evm.token.swaps` | `chainId` (required), `tokenAddress` (required) | Real-time swap events for a token |
| `evm.token.poolInfo` | `chainId` (required), `tokenAddress` (required) | Pool liquidity and info updates |
| `evm.token.balances` | `chainId` (required), `tokenAddress` (required) | Token-scoped balance updates |
| `evm.wallet.nativeBalance` | `walletAddress` (required) | Native token balance updates for a wallet |
| `evm.wallet.tokenBalances` | `walletAddress` (required) | ERC-20 token balance updates for a wallet |
## Alpha signal streams
| Stream | Visibility | Filters | Description |
| --------------------------- | ---------- | ---------------------- | ------------------------------------ |
| `alpha.signalFeed.global` | Public | none | Global trading signal feed |
| `alpha.signalFeed.personal` | Presence | none | Your personalized signal feed |
| `alpha.signalFeed.profile` | Presence | `profileId` (required) | Signals scoped to a specific profile |
| `alpha.signalFeed.named` | Presence | `feedId` (required) | Signals from a named feed |
| `alpha.personal` | Presence | none | Personal alpha messages |
## Portfolio & automation streams
| Stream | Visibility | Filters | Description |
| ------------------------- | ---------- | ------- | -------------------------------------------------------- |
| `portfolio.notifications` | Presence | none | Portfolio update notifications (trades, balance changes) |
| `automation.updates` | Presence | none | Automation trigger status updates |
## Filter reference
| Filter type | Fields | Used by |
| ------------------------ | ------------------------- | -------------------------- |
| **SvmTokenFilter** | `tokenAddress` | `svm.token.*` streams |
| **SvmWalletFilter** | `walletAddress` | `svm.wallet.*` streams |
| **EvmTokenFilter** | `chainId`, `tokenAddress` | `evm.token.*` streams |
| **EvmWalletFilter** | `walletAddress` | `evm.wallet.*` streams |
| **AlphaProfileFilter** | `profileId` | `alpha.signalFeed.profile` |
| **AlphaNamedFeedFilter** | `feedId` | `alpha.signalFeed.named` |
Use the `GET /api/v2/ws/streams` endpoint to get the live catalog with full payload schemas at any time.
# Automation
Source: https://docs.shuriken.trade/browser-extension/automation
Attach take profit and stop loss strategies to trades from the extension.
**Enable automation to automatically attach exit strategies to your trades.** Toggle take profit and stop loss from the extension dashboard, then select from your configured strategies.
## How It Works
When automation is enabled, every buy trade automatically gets a take profit/stop loss strategy attached. The extension uses strategies you've configured in the Terminal.
Automations execute automatically. Once enabled, take profit and stop loss orders trigger without manual confirmation when your conditions are met.
## Enabling Automation
Click the Shuriken extension icon to open the dashboard.
Below the chain rows, check the **Automations** checkbox. It defaults to the **25% TP/SL** strategy on first enable.
Use the dropdown to choose from your available strategies. The selected strategy applies to all future buys.
Execute a buy from the trading modal or quick buy buttons. The selected strategy is automatically attached.
## Strategy Selection
The dropdown shows all automation strategies synced from your Terminal account.
| Button | Action |
| ------- | ----------------------------------------------------------- |
| Add New | Opens the Terminal in a new tab to create a custom strategy |
| Manage | Opens the Terminal in a new tab to edit existing strategies |
Your selected strategy in the extension is **independent** from the Terminal β you can use different strategies on each platform.
## Managing Strategies
Create and edit automation strategies in the Terminal. Custom templates with complex multi-step TP/SL rules appear in the extension dropdown automatically.
Create and manage automation templates
Toggle automations directly in the trading modal
Create automation templates in the Terminal with complex multi-step TP/SL rules, then select them in the extension for one-click trading with automatic risk management.
# Buy & Sell Settings
Source: https://docs.shuriken.trade/browser-extension/buy-sell-settings
Configure preset amounts, gas settings, and wallet selection per chain.
**The settings dashboard is the extension's default landing screen.** Configure quick buy/sell preset amounts, gas settings, and wallet selection for each supported chain.
## Dashboard Overview
Click the extension icon to open the dashboard. You'll see two tabs at the top:
* **Quick Buy** β Configure buy amounts and settings (default view)
* **Quick Sell** β Configure sell amounts and settings
Solana displays as a row with editable amounts, preset selector, and wallet dropdown. Changes save automatically.
## Buy Settings
Each chain row shows:
| Control | Description |
| ------------ | ------------------------------------------------------------------- |
| Amount Input | Editable preset buy amount β click to change |
| Presets | Auto, P1, P2 gas preset buttons β active preset is highlighted |
| Wallet | Wallet selector showing name, shortened address, and native balance |
Select a wallet per chain using the dropdown. Your selection persists across sessions.
## Sell Settings
Switch to the Quick Sell tab to configure sell percentages per chain. These percentages appear as quick-sell buttons in the trading modal and positions header.
## Gas Presets
Access detailed gas configuration by clicking the **Settings** button in the dashboard footer. Each preset (Auto, P1, P2) can be configured with:
| Setting | Description |
| -------------- | ------------------------------------------------------------ |
| Priority Fee | Fee paid to prioritize transaction inclusion |
| Slippage | Maximum acceptable price slippage percentage |
| Tip | Additional tip for transaction processing |
| MEV Protection | Anti-MEV toggle per preset (blue = enabled, gray = disabled) |
Additional options:
* **Per-chain configuration** β select the chain from the dropdown
* **Separate Buy and Sell tabs** within gas presets
* **Order Expiry** β set order expiration (6h, 12h, 24h, 48h)
Settings sync bidirectionally with the web platform β changes in the extension appear in the Terminal and vice versa.
Wallets cannot be created or imported in the extension. Manage your wallets in the [Terminal](https://app.shuriken.trade), and they sync automatically.
Set up P1 for normal trading and P2 with higher fees for congested markets. Switch between them directly in the trading modal.
## Footer Controls
| Button | Action |
| -------- | ------------------------------- |
| Settings | Opens gas presets configuration |
| Logout | Signs out of the extension |
# Instant Trading
Source: https://docs.shuriken.trade/browser-extension/instant-trading
Buy and sell tokens with one click directly on supported sites.
**The trading modal lets you buy and sell tokens without leaving the page you're on.** A draggable modal automatically appears on token pages across supported sites.
## Trading Modal
When you visit a token page on Axiom, Dexscreener, Padre, or GMGN, the trading modal opens automatically:
* Detects the token from the current page β no need to paste addresses
* **Draggable** β reposition anywhere on screen
* **Minimize** β dock as a compact Shuriken widget in the bottom-right corner; click to expand again
## Buying
Visit any token page on a supported site. The trading modal appears automatically.
Choose Auto, P1, or P2 from the preset selector in the modal.
Click one of the preset buy buttons (e.g., 0.5 SOL). The trade executes immediately.
## Selling
Click the quick-sell percentage buttons in the modal to sell a portion of your position. You can also sell directly from the [positions header](/browser-extension/positions-header).
## Modal Features
| Feature | Description |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| Wallet Balance | Current balance for the selected chain, updates in real time |
| Gas Preset Selector | Switch between Auto, P1, P2 directly in the modal. Tap the pencil icon to open extension settings. |
| PnL Display | Position amount, entry price, current price, and unrealized profit/loss (% and \$) at the bottom of the modal |
| Automations Checkbox | Toggle take profit/stop loss directly in the modal β applies to buys only. See [Automation](/browser-extension/automation). |
| Hotkeys | Toggle keyboard shortcuts for trading actions. See [Terminal One-Click Trade](/shuriken-terminal/one-click-trade) for similar hotkeys. |
## Trade Notifications
After each trade, a toast notification confirms:
* Token name and icon
* Transaction status (submitted, success, or failure)
Trades execute immediately β preset buttons have no confirmation step. Make sure your amounts and gas settings are correct before trading.
Configure your preset amounts and gas
Track and sell positions from the header
# Overview
Source: https://docs.shuriken.trade/browser-extension/overview
Trade tokens directly from your favorite crypto sites with one click.
Trade faster on every site you already use β without leaving the page.
**The Shuriken Browser Extension brings your trading setup to every site you already use.** Wallets, presets, and automations sync from your Shuriken account β nothing to configure.
## What can the extension do?
A draggable trading modal appears on token pages across Axiom, Dexscreener, Padre, GMGN, and Solscan. Buy and sell in one click.
A persistent header shows your open positions with real-time PnL on every supported site. Sell directly from the header.
Configure buy amounts, sell percentages, and gas presets once. They follow you across every site.
Attach take profit and stop loss strategies to trades directly from the trading modal.
## How it works
Download for [Chrome](https://cdn.shuriken.trade/extensions/main/chrome.zip) or [Firefox](https://cdn.shuriken.trade/extensions/main/firefox.zip) and load it into your browser.
Click the extension icon and sign in with your Shuriken account. Your wallets and settings sync automatically.
Visit Axiom, Dexscreener, Padre, GMGN, or Solscan. The extension activates automatically β quick buy buttons on list views, the trading modal on token pages.
## Download
**Direct download only.** The extension is not yet available on browser extension stores. Only download extensions from sources you trust.
* [Download for Chrome](https://cdn.shuriken.trade/extensions/main/chrome.zip)
* [Download for Firefox](https://cdn.shuriken.trade/extensions/main/firefox.zip)
Use the extension alongside the Terminal β analyze tokens in the Terminal, then execute trades instantly from any supported site.
# Positions Header
Source: https://docs.shuriken.trade/browser-extension/positions-header
Track real-time PnL and manage positions across all supported sites.
**The universal positions header shows your open positions with real-time PnL on every supported site.** Sell directly from the header without opening the trading modal.
## How It Works
The positions header appears as a persistent bar at the top of supported pages:
* Aggregates positions across all your connected wallets
* Updates PnL in real time β positions refresh automatically after swaps
* Syncs live across all open browser tabs β trade in one tab, see the update everywhere
* Stays visible as you navigate between pages
## Position Information
| Column | Description |
| ------------ | ------------------------------------------------------------------- |
| Token | Token name and icon |
| PnL | Real-time unrealized profit/loss (% and \$) |
| Value | Current position value |
| Sell Buttons | Quick sell percentage buttons matching your configured sell presets |
## Selling from the Header
Click a sell percentage button to instantly sell that portion of your position β no need to navigate to the token page.
Click a position's token name to open the [Shuriken Terminal](https://app.shuriken.trade) trade page for that token.
## Filtering
Dust positions and low-liquidity tokens are automatically filtered out. Use the filter button next to the Shuriken logo to adjust filtering.
On Axiom, the extension provides both the universal positions header and injects sell buttons into Axiom's native position bar. The same pattern applies on Padre and GMGN.
Configure your sell preset percentages
Buy and sell from the trading modal
# Quick Start
Source: https://docs.shuriken.trade/browser-extension/quick-start
Install the extension and make your first trade in minutes.
This guide walks you through installing the extension, logging in, and executing your first trade.
You need an existing Shuriken account. If you don't have one yet, sign up at [app.shuriken.trade](https://app.shuriken.trade).
## Your First Trade
**Direct download only.** The extension is not yet available on browser extension stores. Only download extensions from sources you trust.
Download the extension for your browser:
* **Chrome**: [Download chrome.zip](https://cdn.shuriken.trade/extensions/main/chrome.zip)
* **Firefox**: [Download firefox.zip](https://cdn.shuriken.trade/extensions/main/firefox.zip)
**Chrome:**
1. Unzip the downloaded file
2. Go to `chrome://extensions/`
3. Enable "Developer mode" (top right)
4. Click "Load unpacked" and select the unzipped folder
**Firefox:**
1. Go to `about:debugging#/runtime/this-firefox`
2. Click "Load Temporary Add-on"
3. Select the downloaded zip file
After installation, a new tab opens to the Shuriken documentation.
Click the puzzle icon in your browser toolbar and pin the Shuriken extension for quick access.
Click the Shuriken extension icon to open the popup. Click **Login with Webapp** β a new tab opens to the Shuriken Terminal.
* If you're already logged in, the extension activates immediately
* If not, log in to your Shuriken account in the new tab
Once authenticated, the extension shows the Quick Buy/Sell Settings dashboard.
Navigate to any token page on [Axiom](https://axiom.trade), [Dexscreener](https://dexscreener.com), [Padre](https://padre.trade), or [GMGN](https://gmgn.ai). The trading modal appears automatically.
In the trading modal:
1. Select your gas preset (Auto, P1, or P2)
2. Click a preset buy amount (e.g., 0.5 SOL)
3. The trade executes immediately β a toast notification confirms submission
Your new position appears in the positions header at the top of the page.
Login is required for all features. The extension gates all functionality behind authentication.
## Session Management
Your extension session is independent from the web platform:
* Logging out of the Terminal does **not** log you out of the extension
* Logging out of the extension does **not** log you out of the Terminal
* Your extension session persists indefinitely until you explicitly sign out
## Next Steps
Configure presets and gas settings
See where the extension works
# Supported Sites
Source: https://docs.shuriken.trade/browser-extension/supported-sites
See which crypto sites work with the Shuriken extension and what features are available.
**The extension works across major crypto platforms.** Each site supports the trading modal with additional platform-specific features.
## Feature Matrix
| Feature | Axiom | Dexscreener | Padre | GMGN |
| --------------------------- | ----- | ----------- | ----- | ---- |
| Trading Modal (Token Pages) | β | β | β | β |
| Quick Buy (List Views) | β | β | β | β |
| Positions Header | β | β | β | β |
| Portfolio/Positions Pages | β | β | β | β |
| Watchlist | β | β | β | β |
| Search Integration | β | β | β | β |
## Per-Site Details
Quick buy buttons appear on token rows across all list views. On token pages, the full trading modal opens automatically.
**Positions:** The extension provides both the universal positions header and injects sell buttons into Axiom's native position bar. Watchlist pages display buy buttons for each token.
The trading modal appears on token pages with real-time wallet balance updates. Quick buy buttons display on trending and new pair views.
The universal positions header displays across all Dexscreener pages. Search integration lets you buy directly from search results.
Full trading support across all Padre views. Positions, watchlist, and recent pages include buy/sell button injection.
Quick buy buttons on list views, trading modal on token pages. Native positions and watchlist pages include buy/sell injection.
The extension also provides limited support on **Solscan** β the universal positions header is available for tracking your open positions while browsing token data.
The extension automatically detects which site you're on and injects the right features. No per-site configuration needed.
# Troubleshooting
Source: https://docs.shuriken.trade/browser-extension/troubleshooting
Solutions for common issues with the Shuriken Browser Extension.
## Common Issues
### Extension Not Appearing on Sites
**Symptoms**: No quick buy buttons or trading modal on supported sites.
**Solutions**:
1. Ensure the extension is enabled in your browser's extension settings
2. Refresh the page (Ctrl/Cmd + R)
3. Check that you're logged into the extension
4. Verify you're on a [supported site](/browser-extension/supported-sites) (Axiom, Dexscreener, Padre, GMGN, Solscan)
### Settings Not Syncing
**Symptoms**: Changes made in extension don't appear in Terminal, or vice versa.
**Solutions**:
1. Refresh the extension by clicking the icon and waiting for reload
2. Log out and log back in to re-sync your account
3. Clear browser cache for the Shuriken domain
4. Check your internet connection
### Trade Execution Failed
**Symptoms**: Trade doesn't execute or shows error.
**Solutions**:
| Check | Solution |
| --------------- | ----------------------------------------------- |
| Wallet balance | Ensure sufficient funds for trade + gas |
| Slippage | Increase slippage in preset settings |
| Gas settings | Increase priority fee during network congestion |
| Token liquidity | Some tokens may have low liquidity |
### Wallet Balance Shows Incorrect Amount
**Symptoms**: Balance in dropdown doesn't match actual wallet balance.
**Solutions**:
1. Click away and reopen the wallet dropdown
2. Refresh the page
3. Check the balance on [Shuriken Terminal](https://app.shuriken.trade)
4. Verify the correct chain is selected
### Login Issues
**Symptoms**: Can't log in or extension shows loading indefinitely.
**Solutions**:
1. Ensure you have an active Shuriken account
2. Try logging into [app.shuriken.trade](https://app.shuriken.trade) directly first
3. Clear browser cookies and cache
4. Disable other browser extensions that might interfere
5. Try in an incognito/private window
### Positions Not Updating
**Symptoms**: Positions header doesn't show recent trades.
**Solutions**:
1. Refresh the page
2. Check that the trade executed successfully on-chain
3. Verify you're viewing the correct wallet
4. Wait a few seconds for cross-tab sync to complete
## FAQ
### Does logging out of the Terminal log me out of the extension?
No. The extension maintains an independent session. Logging out of the Shuriken web platform does not affect your extension session.
### Can I use different wallets for different chains?
Yes. Solana has its own wallet selector in the extension dashboard.
### Do automation settings sync between extension and Terminal?
The available strategies sync β create on either, available on both. However, your **selected** automation is independent. You can use different strategies for extension and Terminal trading.
### Which browsers are supported?
Chrome and Firefox are both fully supported. Download from the links on the [Overview](/browser-extension/overview) page.
### Can I create new wallets from the extension?
No. Wallet creation and import must be done on the [Shuriken Terminal](https://app.shuriken.trade). The extension provides quick access to your existing wallets.
### Why don't I see the extension on some sites?
The extension only activates on [supported sites](/browser-extension/supported-sites): Axiom, Dexscreener, Padre, GMGN, and Solscan. More integrations are coming.
## Get Help
If you're still experiencing issues:
* Contact support via [Telegram](https://t.me/ShurikenSupportBot)
* Check the [Shuriken Twitter](https://x.com/ShurikenTrade) for status updates
# Welcome to Shuriken
Source: https://docs.shuriken.trade/introduction
From signals to trade, faster
**We built Shuriken for speed:** from the moment a signal fires to the moment your trade hits the chain. Shuriken turns the noise of Discord and Telegram into actionable trading signals. Connect to any server or group, build custom alerts based on token mentions and sender reputation, and execute trades across Solana, Base, BSC, and Monad β all from one interface.
The full trading experience. Set up signals, analyze tokens, and execute trades from the web platform.
Trade directly from Telegram when you're away from your desk. Same speed, same wallets.
Let an AI agent monitor your alpha, research tokens, and trade for you. No code, no server β set it up in 60 seconds.
# The Alpha Signal Advantage
Source: https://docs.shuriken.trade/shuriken-terminal/advantage
Discover the powerful, high-performance architecture that drives the Alpha Platform.
The Alpha Platform is built from the ground up for the demands of high-frequency traders. We've engineered a system that delivers speed, accuracy, and power, so you can focus on the signal, not the noise.
All your alpha, one feed. Stop switching between a dozen apps and focus on what matters.
Go beyond keywords. Filter by market cap, liquidity, token age, mention frequency, and more.
Engineered for speed. We process and deliver signals from message-to-screen in under 500ms (dependent upon user network conditions).
Our evaluation engine processes every message atomically, ensuring signals are never missed due to race conditions. What you see is what's real.
### Your Access, Your Signals
The Alpha Platform respects and enforces your existing access permissions. You will **only** receive signals from Discord servers and Telegram groups that you already have legitimate access to through your connected accounts.
When you connect your Discord or Telegram account, Shuriken uses your credentials to verify your memberships. We don't grant you access to anything newβwe simply surface the alpha from communities you're already a part of, faster and smarter.
This means:
* **No unauthorized access**: If you're not a member of a private group, you won't see signals from it.
* **Your permissions, amplified**: We take what you already have access to and make it actionable.
* **Transparent & compliant**: Your account connections are used solely to verify access rights, never to act on your behalf without consent.
# Analytics Dashboard
Source: https://docs.shuriken.trade/shuriken-terminal/analytics-dashboard
Analyze group performance, track top callers, and identify trends across your connected alpha sources.
**The Analytics Dashboard gives group owners a complete performance overview of their Discord servers and Telegram groups.**
Use it to measure caller accuracy, spot emerging trends, and identify low-quality participants across your alpha sources.
The Analytics Dashboard is available to **group owners** -- Discord server owners and Telegram group administrators. If you are a member of a group but not its owner, you will not have access to this dashboard for that group.
## Accessing the Dashboard
Click the **Analytics** tab in the top navigation bar of the Shuriken Terminal. The dashboard is a single scrollable page that displays all metrics, charts, and tables for the groups you own.
If you haven't connected a group yet, use the **Add Bot** button on the dashboard or follow the [connection guide](/shuriken-terminal/connection-methods).
## Header Metrics
Six stat cards at the top of the dashboard provide a high-level snapshot of your group's activity. Each card displays the current value and a percentage change compared to the previous period.
| Metric | Description |
| ---------------- | -------------------------------------------------------------------------------------- |
| Total Calls | Number of alpha calls (token mentions) made in the selected period |
| Win Rate | Percentage of calls that achieved a 2x or higher return from entry price to peak price |
| Average Return | Mean multiplier across all calls (e.g., 1.9x) |
| Unique Contracts | Number of distinct tokens mentioned as calls |
| Total Messages | Total messages indexed from the selected source |
| Active Members | Number of members who participated during the period |
Percentage changes are color-coded: **green** indicates an increase and **red** indicates a decrease compared to the previous equivalent period.
## Source Filtering
Filter your analytics by specific groups using the **source chips** at the top of the dashboard.
* **All** -- View aggregated data across every group you own
* **Individual sources** -- Click a specific Discord server or Telegram group chip to isolate analytics for that group
This lets you compare performance across your groups and identify which ones deliver the highest-quality alpha.
## Time Period Filters
Control the time range for all dashboard data using the period toggles in the top-right corner:
| Period | Description |
| ------ | ----------------------------- |
| 1d | Last 24 hours |
| 7d | Last 7 days |
| 30d | Last 30 days |
| All | All available historical data |
When you switch periods, the header metric cards update their percentage changes to compare against the equivalent previous period. For example, selecting **7d** compares the last 7 days against the 7 days before that.
## Filters
The dashboard provides two types of filters to refine your data.
### View Toggle
Switch between two caller views using the **View** toggle:
* **Callers** -- Show all callers, including repeated mentions of the same token
* **First Callers** -- Show only the first person to call each token, filtering out duplicate mentions
### Chain and Call Filters
Click the **Filter** button to open additional filtering options:
* **Chain filter** -- Narrow results to a specific blockchain network (Solana, BSC, or Monad). When active, all header metrics, charts, and tables update to reflect only calls on the selected chain.
* **Min/Max calls** -- Set a minimum or maximum number of calls to include a caller in the tables. Use this to filter out low-activity users or focus on high-volume callers.
## Charts
Two charts visualize activity trends over the selected time period.
### Messages vs Calls
A dual-line area chart comparing total messages against alpha calls over time.
* **Green line** -- Total messages (typically higher volume)
* **Teal line** -- Alpha calls (token mentions)
Hover over any point to see exact counts for that day. A healthy group typically shows consistent message activity alongside its call volume, indicating genuine community engagement beyond token mentions.
### Unique Users
A single-line area chart tracking the number of unique active users per day. Use this to monitor community engagement trends and identify periods of growth or decline in your group.
## Top Callers
The **Top Caller** tab ranks your group members by their alpha call performance. Use this leaderboard to identify the most accurate and active callers.
| Column | Description |
| -------------- | ---------------------------------------------------------------------- |
| Rank | Position on the leaderboard (gold, silver, and bronze icons for top 3) |
| User | Member name with a color-coded indicator |
| Total Returns | Cumulative return across all calls |
| Total Mentions | Number of token mentions by this caller |
| Best Return | Highest single-call multiplier achieved |
| Win Rate | Percentage of calls achieving a 2x or higher return |
| Best Call | The token that produced the caller's highest return |
| Calls | Total number of alpha calls made |
| Messages | Total messages sent in the group |
| Call Ratio | Ratio of calls to total messages, shown as a percentage |
The table is sorted by **Best Return** (descending) by default. Click any sortable column header to change the sort order.
## Leech Detection
The **Leech Detection** tab uses the same data as the Top Caller table but is sorted by **Call Ratio** (ascending). It highlights members who post a disproportionately high number of token calls relative to their overall message activity.
A high call ratio with low general engagement can indicate a "leech" -- someone who copies calls from other sources and pastes them into the group without contributing to the community discussion.
Use this view to:
* Identify potential copy-callers who may be reposting alpha from other groups
* Evaluate whether a caller's contributions are original or duplicated
* Maintain the quality of your group by flagging suspicious activity
## Distribution Charts
Two pie charts break down call data by category.
### Chain Distribution
Shows the percentage of calls targeting each blockchain network (e.g., Solana, BSC, Monad). Use this to understand which chains your group's callers focus on.
### Platform Distribution
Shows the percentage of calls by decentralized exchange or launchpad (e.g., PumpFun, Raydium, Meteora). This reveals which trading venues your callers are most active on.
## Trending Tokens and Top Calls
A tabbed table at the bottom of the dashboard surfaces the most notable tokens across your groups.
### Trending Tokens
Ranked by **Total Mentions** (descending), this tab shows the most talked-about tokens.
| Column | Description |
| -------------- | ------------------------------------------------------- |
| Rank | Position by mention count |
| Token | Token name and ticker |
| Current MC | Current market capitalization |
| First Caller | The member who mentioned the token first |
| Called @ MC | Market cap at the time of the first call |
| ATH MC | All-time high market capitalization |
| Multiplier | Return from first call price to all-time high |
| Total Mentions | Number of times the token was called across all sources |
### Top Calls
Uses the same columns as Trending Tokens but sorted by **Multiplier** (descending). This view highlights the best-performing calls by return, regardless of how many times the token was mentioned.
Both tabs include chain filter icons in the top-right corner to narrow results by network.
# Charts & Data
Source: https://docs.shuriken.trade/shuriken-terminal/charts-and-data
View price charts and on-chart indicators.
**The main chart area displays price data for the selected token.**
Charts include visual indicators for alpha calls and your own trades.
## Alpha Call Bubbles
When a token has been called by your connected alpha sources, bubbles appear on the chart at the time of each call.
* Hover over a bubble to see the caller and source
* Click to view the original message
* Multiple calls at similar times are grouped
## Trade Bubbles
Your own trades are displayed on the chart:
* **Buy markers**: Show where you purchased
* **Sell markers**: Show where you sold
* Hover to see trade details (amount, price, time)
## Display Options
Toggle between different views using the chart controls:
* **Price/MCap**: Switch between price and market cap on the Y-axis
* **Volume**: Show or hide volume bars below the chart
# Personal Account Setup
Source: https://docs.shuriken.trade/shuriken-terminal/connect-byo-alpha
Advanced guide for connecting a personal Discord or Telegram account for maximum access.
This method is for power users who need to access private, invite-only groups using a dedicated "alpha burner" account.
**This is an advanced feature.** Before proceeding, please review the risks and recommendations in the [Choosing Your Connection Method](/shuriken-terminal/connection-methods) guide. We strongly advise using a dedicated "burner" account that does not contain sensitive personal information.
**Discord BYO is not currently enabled.**\
At this time, you can only connect a personal **Telegram** account using this method. BYO for Discord is not enabled.
### How It Works
By providing an authorization token for a personal Telegram account, you allow the Shuriken Platform to process messages on your behalf.
The system will ingest messages from all servers and chats that the connected account is a member of.
# Discord Bot Setup
Source: https://docs.shuriken.trade/shuriken-terminal/connect-discord-bot
A step-by-step guide to connecting your Discord server using the official Shuriken Bot.
Connecting via the Official Shuriken Bot is the most secure and straightforward way to get your Discord server's data into the Alpha Platform.
**Before you start** β Your Discord account must be connected to the Terminal for your server's feed to appear. Click the **Discord icon** in the top header bar, or go to **Profile > Integrations** to link it.
### How It Works
The bot operates like any other standard Discord bot. Once invited, it will index messages from channels it has been given access to. Activation by a server owner or administrator is required before any message data is processed, ensuring full control and transparency.
The first step is to invite the official Shuriken Bot to your Discord server. You must have `Administrator` or `Manage Server` permissions to do this.
[**Click here to invite the Shuriken Bot**](https://discord.com/oauth2/authorize?client_id=1440745309775990794\&permissions=8\&integration_type=0\&scope=bot)
The bot requires a basic set of permissions to read messages and view channels. It will never post messages, manage roles, or perform any administrative actions.
For security and privacy, message processing does not begin automatically. A user with **Owner** or **Administrator** privileges in the Discord server must explicitly activate it.
* In the Shuriken Terminal, an **"Activate"** button will appear for authorized users.
* Click this button to grant the bot permission to begin indexing messages.
Once activated, you will see a confirmation, and messages from your server will begin to appear in your unified feed in real-time.
# Telegram Bot Setup
Source: https://docs.shuriken.trade/shuriken-terminal/connect-telegram-bot
A step-by-step guide to connecting your Telegram group using the official Shuriken Bot.
Connecting via the Official Shuriken Bot is the most secure and straightforward way to get your Telegram group's data into the Alpha Platform.
### How It Works
The bot operates like any other standard Telegram bot. Once added to a group, it will index messages from that chat.
The first step is to add the official Shuriken Bot to your Telegram group. You must be a group **Owner** or **Administrator** to do this.
To add the bot:
1. Open your Telegram group settings
2. Navigate to **Add Members** or **Add Administrators**
3. Search for `@shuriken_alpha_bot` and add it to the group
The bot only requires permission to read messages. It will never send messages, manage members, or perform any administrative actions in your group.
After adding the Shuriken Bot to your Telegram group, you must send a message in the group to confirm your membership. This step is required because Telegram only allows the bot to see active members who have recently participated in the chat.
* Send any message (even something simple like "hello") into your Telegram group.
* This allows the bot to recognize your membership and make the group eligible for connection in the Shuriken Terminal.
* If you skip this step, your group may not appear in the list of available connections.
Once you have sent a message in the group and the bot recognizes your membership, navigate to the **Alpha Platform** section in your Shuriken Terminal.
* Your Telegram group should now appear in the list of available connections.
* Click **"Connect"** to link the group to your Shuriken account.
After connecting, you'll be able to activate the group for message indexingβmessages will begin to appear in your unified feed in real time once activation is complete.
For **private groups** or **channels**, ensure the bot has been granted read access. If the bot cannot see messages, they will not appear in your Alpha Platform feed.
# Connect Your Accounts
Source: https://docs.shuriken.trade/shuriken-terminal/connection-methods
Learn the two ways to connect your Discord and Telegram sources to the Alpha Platform.
There are two primary ways to connect your alpha sources to Shuriken. For most users, the Official Bots provide the simplest and most secure setup. For power users needing to access private groups, the "Bring Your Own Alpha" (BYO Alpha) method offers maximum flexibility.
We **strongly recommend** starting with the Official Shuriken Bots. They are purpose-built for security, simplicity, and respecting platform permissions.
**Discord users** β Before connecting a server, make sure your Discord account is linked to the Terminal. Click the **Discord icon** in the top header bar, or go to **Profile > Integrations**.
Invite the bot to your Discord server, authorize, and you're done. No personal accounts involved.
The bot only sees what you allow it to see, operating within the standard Discord permission model you already know.
**Best for:**
* Most traders and alpha groups.
* Community owners who want to provide signals to their members.
* Anyone who wants a secure, "set it and forget it" solution.
Get your community owner to install the official bot! It's the de facto way to connect your group's alpha and the best way to ensure everyone in your group can benefit securely.
[Get Started with the Discord Bot](/shuriken-terminal/connect-discord-bot)
Connect a personal Discord or Telegram account to access private, invite-only groups you're a member of.
The system will process all messages from all joined servers/chats for signal evaluation.
**Best for:**
* Power users with dedicated "alpha burner" accounts.
* Accessing private alpha sources where bots are not allowed.
**Privacy & Terms of Service Notice**
This advanced method requires connecting a personal user account. Our service will process all messages from that account for signal evaluation. You are responsible for complying with the platform's (Discord/Telegram) Terms of Service.
We make no guarantees of end-to-end privacy when using this method and only recommend it for **dedicated "burner" accounts**.
[Learn how to connect a personal account](/shuriken-terminal/connect-byo-alpha)
# Exit Strategies
Source: https://docs.shuriken.trade/shuriken-terminal/exit-strategies
Automatically place limit orders when you buy.
**Exit strategies are limit orders placed automatically when you execute a buy.**
Use them to trade safely or stick to your strategy without manual intervention.
## How Exit Strategies Work
When you buy a token with an exit strategy enabled, the system automatically creates limit orders based on your strategy settings. These orders execute when your conditions are met.
Exit strategies only apply to buy orders. They are not applied when selling.
## Predefined Strategies
There are five predefined exit strategies available:
* Select a strategy from the dropdown menu before buying
* The strategy's limit orders are created alongside your buy
## Custom Strategies
You can create and customize your own exit strategies:
* Open the strategy dropdown menu
* Create a new strategy or edit an existing one
* Set your own Take Profit and Stop Loss percentages
* Save and select your custom strategy for future trades
# FAQ
Source: https://docs.shuriken.trade/shuriken-terminal/faq
Common questions about the Shuriken Terminal.
## Alpha Signals
There are a few common reasons for this:
1. **Server Not Activated:** A server Owner or Administrator must activate the server in the Shuriken Terminal before message processing can begin. Check the connection status in the Alpha Platform settings.
2. **Bot Permissions:** Ensure the Shuriken Bot has the necessary `View Channel` and `Read Message History` permissions for the specific channels you want to monitor.
3. **User Access:** The system respects Discord's permission model. You will only see messages from channels that you personally have access to.
This is usually due to one of the signal's conditions or safety features:
1. **Conditions Not Met:** The mentioned token may not have met your specific criteria for market cap, liquidity, or age.
2. **24-Hour Deduplication:** To prevent spam, a signal will only fire once per token every 24 hours by default. If the same token was alerted on recently, it will be skipped.
3. **Max Fires Reached:** Check if your signal has a `Max Fires` limit. If it has reached its limit, it will be automatically disabled.
4. **Signal Disabled:** Verify that the signal is enabled in your signal list.
Security is our top priority.
* **Official Bots:** When using the recommended Official Shuriken Bots, the system operates within the standard, secure permission models of Discord and Telegram. The bot only has access to what you explicitly grant it.
* **Personal Accounts (BYO Alpha):** When you connect a personal account, we encrypt your access token and use it only to process messages for signal evaluation. However, this method gives our system broad access to your account's messages. We strongly recommend using a dedicated "burner" account for this purpose.
Token metadata is fetched in near real-time. When a signal evaluation is triggered, we fetch the latest on-chain data for the mentioned token. There may be a few seconds of latency, but the data is generally very current.
## Trading
Common reasons for failed trades:
* **Insufficient balance**: Check your wallet has enough tokens plus fees
* **Slippage too low**: Price moved before confirmation. Try increasing slippage
* **Low liquidity**: The token may not have enough liquidity for your order size
* **Network congestion**: Try increasing the priority fee
Limit orders only execute when price reaches your trigger level:
* **Price hasn't reached trigger**: The order is waiting for your conditions
* **Insufficient liquidity at trigger**: Large orders may need price to move further
* **Order expired**: Some orders have time limits
Go to the Orders table, find your order in the "Open" tab, and click the cancel button. A small transaction fee may apply on some chains.
**Market orders** execute immediately at the current price. **Limit orders** wait for price to reach your specified level before executing.
Access Settings in the Execution Panel to customize your preset buy amounts.
Yes. The Trading Terminal supports Solana (SVM), Base (EVM), BSC (EVM), and Monad (EVM). Each chain requires a compatible wallet.
Anti-MEV protection routes your transactions to prevent sandwich attacks and protects against front-running.
When you buy with exit strategies enabled, Take Profit and Stop Loss orders are automatically created. These remain active until triggered or you cancel them.
# Create a Signal
Source: https://docs.shuriken.trade/shuriken-terminal/first-signal
A step-by-step tutorial to build a simple signal and start receiving real-time alerts.
Let's build a "Hello, World!" signal. This tutorial will guide you through creating a basic signal that alerts you whenever a specific token is mentioned in a channel you've connected.
From the Shuriken Terminal, go to the **Alpha Platform > Signals** tab. Click the **"Create New Signal"** button to open the signal editor.
First, tell the signal which chats to monitor.
* Give your signal a name, like "My First Token Alert".
* In the "Sources" section, click **"Add Source"**.
* Select the Discord server and the specific channel(s) you want to watch. You can add multiple sources to a single signal.
For this first signal, we'll keep it simple and not add any advanced conditions. By default, the signal will fire on **any token mention**.
We will explore advanced conditions like market cap and liquidity in the [Signal Conditions](/shuriken-terminal/signal-conditions) guide.
Ensure the **"Enabled"** toggle is on. Click **"Save Signal"**.
That's it! Your signal is now live. The next time a message containing a valid token address β whether on Solana (SVM) or an EVM chain like Base, BSC, or Monad β is sent in your selected channel(s), you will receive a real-time notification in your Terminal.
### What Happens Next?
When your signal fires, you'll see a notification that includes:
* The message content that triggered the signal.
* Enriched metadata about the token (market cap, liquidity, age, etc.).
* A direct link to the message in its original platform.
### Track Interesting Wallets
Discover a wallet making great trades? You can [create a profile](/shuriken-terminal/profiles) for them and track all their future activity directly in your feed.
### Acting on Signals
When you see a signal you want to trade, click the token to open it in the [Trading Terminal](/shuriken-terminal/interface-overview). From there you can:
* [Execute a market order](/shuriken-terminal/market-orders) with preset amounts
* [Set a limit order](/shuriken-terminal/limit-orders) to buy at a specific price
* Review [token analytics](/shuriken-terminal/token-analytics) before deciding
# Import Wallets
Source: https://docs.shuriken.trade/shuriken-terminal/import-wallets
Bring your wallet tracking setup from Axiom, Padre, GMGN, Cielo, or Ray Bot - everything transfers.
**Bring your entire wallet tracking setup from any platform.** Everything transfers - names, groups, and organization.
## Everything Comes With You
Your wallet addresses, display names, emojis, and group organization all transfer to Shuriken. After importing, you can enrich each profile with social accounts and tags - something your previous platform couldn't do.
| What | Transfers? |
| ----------------------- | ---------------------------- |
| Wallet addresses | Yes |
| Display names | Yes |
| Emojis | Yes |
| Group/list organization | Yes, mapped to profile lists |
## Supported Platforms
| Platform |
| -------- |
| Axiom |
| Padre |
| GMGN |
| Cielo |
| Ray Bot |
Export your wallet list from your current platform, then paste it into Shuriken. The format is auto-detected.
## Import Your Wallets
Open the **Wallet Tracking** page from the sidebar.
Click the **Import** button to open the import dialog.
Paste your exported data into the text field. Shuriken detects the format automatically (e.g., "Detected: Axiom format").
Review the preview and map your imported groups to Shuriken profile lists.
Click **Confirm** to import. Your wallets appear immediately on the Wallet Tracking page.
## Import Limits
* **200 wallets per list** - if a group exceeds this, it auto-splits into "List Name (1)", "List Name (2)", and so on.
* **Duplicate wallets are skipped** and reported in the import summary.
## After Importing
Your profiles are ready, but you can make them even more powerful:
* **Link social accounts** - connect Discord and Telegram accounts to see social calls alongside wallet activity.
* **Add tags** - categorize profiles by strategy, performance, or any label you choose.
## Next Steps
Add social accounts and tags to your imported wallets.
Set up alerts based on wallet activity.
# Interface Overview
Source: https://docs.shuriken.trade/shuriken-terminal/interface-overview
Learn the layout of the Trading Terminal.
**The Trading Terminal is organized into four main areas.**
Each area handles a specific function: discovering tokens, viewing charts, executing trades, and analyzing data.
## Main Layout
The Trading Terminal interface is divided into four key sections:
### Left Sidebar: Recent Calls
The collapsible left sidebar displays your **Recent Calls**, a real-time feed of alpha signals from your connected Discord, Telegram, and X sources. It also shows activity from your [tracked wallets](/shuriken-terminal/wallet-signals), so on-chain moves appear right alongside social calls.
* Click any token to load it in the main view
* See key metrics at a glance: market cap, liquidity, transaction count
* Quick-buy buttons for market orders directly from the feed
### Main Area: Charts
The center of the terminal displays candlestick charts for the selected token.
* Multiple timeframes (1m, 5m, 15m, 1h, 4h, 1D)
* Volume indicators
* **Alpha Call Bubbles** showing when signals fired for this token
* **Trade Bubbles** showing your buy/sell transactions on the chart
* Price and market cap display toggle
### Right Sidebar: Execution Panel
The right sidebar contains all trading controls.
* **Buy/Sell Toggle**: Switch between buying and selling
* **Market/Limit Mode**: Choose market orders or set price targets
* **Quick Amount Buttons**: Preset amounts (0.1, 0.5, 1 SOL)
* **Percentage Sell Buttons**: Sell 25%, 50%, 75%, or 100% of your position
* **Wallet Selector**: Choose which connected wallet to trade from
* **Exit Strategies**: Attach Take Profit and Stop Loss orders to your buy orders
* **Settings**: Configure slippage, priority fee, and MEV protection
### Bottom Table: Token Data
The bottom section provides detailed token information across multiple tabs:
| Tab | Description |
| ---------------- | ---------------------------------------------- |
| **Transactions** | Real-time swap activity for the token |
| **Holders** | Top holders ranked by balance with wallet tags |
| **Positions** | Your current position in this token |
| **Orders** | Your open and closed orders for this token |
| **Alpha** | Historical alpha calls for this token |
Each section can be resized or collapsed to customize your workspace.
## Quick Navigation
Learn about charting tools and data visualization.
View holder analysis and token metrics.
Execute trades from the Execution Panel.
Configure slippage, fees, and MEV protection.
# Limit Orders
Source: https://docs.shuriken.trade/shuriken-terminal/limit-orders
Set buy and sell orders at specific market cap targets.
**Limit orders execute automatically when market cap reaches your target.**
Set your conditions and let the system monitor for you.
## How Limit Orders Work
Unlike market orders that execute immediately, limit orders wait for the market cap to reach your specified level. Once triggered, they execute as market orders.
## Order Types
### Buy Limit
Set a target market cap to automatically buy a token when it reaches that level.
**Example**: Set a buy order at 5M market cap. When the token drops to 5M, your order executes automatically.
### Take Profit
Automatically sells when market cap rises to your target. Use this to lock in gains.
**Example**: You bought at 5M market cap. Set Take Profit at 10M to sell at 2x.
### Stop Loss
Automatically sells if market cap drops to your target. Use this to limit losses.
**Example**: You bought at 5M market cap. Set Stop Loss at 2.5M to exit if the token drops 50%.
## Creating a Limit Order
Click **Limit** in the Execution Panel.
Enter the market cap at which the order should execute.
Enter the amount to buy or sell when triggered.
Click the buy button (shows trigger market cap) to submit. View it in the Orders table.
When a limit order triggers, it executes as a market order. In volatile conditions, the actual execution price may differ from your trigger price due to slippage.
## Managing Orders
The Orders table displays your limit orders with the following columns:
| Column | Description |
| ------- | ---------------------------------------- |
| Token | Token name and address |
| Type | Order type (Buy, Take Profit, Stop Loss) |
| Trigger | Market cap that will trigger execution |
| Amount | Order size |
| Status | Current state of the order |
### Open Orders
The **Open** tab shows orders waiting to be triggered:
* Orders remain open until the trigger price is reached
* You can cancel open orders at any time
* Open orders are monitored continuously
### Closed Orders
The **Closed** tab shows your order history:
* **Filled**: Order triggered and executed successfully
* **Cancelled**: Order was manually cancelled
### Grouped Orders
When you create exit strategies (Take Profit + Stop Loss) with a buy order, they appear grouped together in the table. Expanding a group shows all related orders.
## Cancelling Orders
Locate the order in the Open tab.
Click the cancel button on the order row. The order is cancelled immediately and moves to the Closed tab with "Cancelled" status.
# Market Orders
Source: https://docs.shuriken.trade/shuriken-terminal/market-orders
Buy and sell at the current market price.
**Market orders execute immediately at the best available price.**
Use preset amounts for quick execution when timing matters.
## How Market Orders Work
A market order buys or sells at the best available price right now. Unlike limit orders, market orders execute immediately but the exact price may vary slightly due to slippage.
## Buying
The Execution Panel provides preset buy amounts:
* Click a preset button (0.1, 0.5, 1 SOL) to buy that amount
* Or enter a custom amount in the input field
* Click **Buy** to execute
## Selling
Sell buttons let you exit positions by percentage:
| Button | Action |
| ------ | ------------------------------------ |
| 25% | Sell one quarter of your position |
| 50% | Sell half of your position |
| 75% | Sell three quarters of your position |
| 100% | Sell your entire position |
## Wallet Selector
If you have multiple wallets connected, select which wallet to trade from using the wallet dropdown in the Execution Panel.
## Exit Strategies
When buying, you can attach [exit strategies](/shuriken-terminal/exit-strategies) that automatically create Take Profit and Stop Loss orders alongside your buy.
# One-Click Trade
Source: https://docs.shuriken.trade/shuriken-terminal/one-click-trade
Execute orders without confirmation prompts.
**One-Click Trade removes the confirmation step from order execution.**
Enable this for faster trading when you're confident in your settings.
## How It Works
When One-Click Trade is enabled:
* Clicking a buy amount immediately executes the order
* Clicking a sell percentage immediately sells that portion
* Works for both market orders and limit orders
## Hotkeys
Enable hotkeys to trade using your keyboard:
* Press **Spacebar** to see which key is mapped to each amount
* Press **Spacebar + Key** to execute that trade
This allows you to buy or sell preset amounts without touching your mouse.
One-Click Trade executes orders without confirmation. Make sure your settings (slippage, amount) are correct before enabling.
# Overview
Source: https://docs.shuriken.trade/shuriken-terminal/overview
Turn real-time social intelligence into executed trades with the Shuriken Terminal.
**The Shuriken Terminal is a complete trading platform that combines real-time social intelligence with multi-chain trade execution.**
Turn the deafening firehose of Discord and Telegram chatter into actionable signalsβthen execute trades without leaving the interface.
## Alpha Signals
The Alpha Platform allows you to:
* **Connect** to any Discord server or Telegram chat
* **Signal** on token mentions with sophisticated, custom-built rules
* **Act** on real-time alerts delivered directly to your terminal
Learn how to connect Discord and Telegram to start the data flow.
A step-by-step guide to building your first real-time signal.
## Wallet & Profile Tracking
Track the people behind the wallets - not just addresses. Shuriken's profile-enhanced wallet tracking lets you:
* **Build profiles** for every trader worth watching - link all their wallets and social accounts in one place
* **Import** your existing wallet lists from Axiom, Padre, GMGN, Cielo, or Ray Bot in under a minute
* **Get signals** when tracked wallets make moves - right in your Recent Calls feed alongside social alpha
See how profile-enhanced tracking works.
Create and manage trader profiles.
## Trading Terminal
The Trading Terminal includes:
* **Market Orders**: Execute buy and sell orders at the current market price
* **Limit Orders**: Set entry and exit points that execute automatically
* **Token Analytics**: View holder data, charts, and market metrics
* **Multi-Chain Support**: Trade on Solana, Base, BSC, and Monad from one interface
Learn the layout and navigation of the Trading Terminal.
Understand chain-specific features and how to switch between them.
Buy and sell at current market prices.
Set automated buy and sell orders at specific price targets.
**New to crypto trading?** Check our [Trading Glossary](/shuriken-terminal/trading-glossary) for explanations of key concepts like slippage, limit orders, and market cap.
# Profiles
Source: https://docs.shuriken.trade/shuriken-terminal/profiles
Create profiles for traders you follow - link their wallets and social accounts in one place.
**Create profiles for the traders you follow - link their wallets and social accounts so you never miss a move.**
## Create a Profile
In any transaction table, click a maker address to open the wallet modal.
The wallet modal shows that wallet's recent trades and token activity.
Type a display name to create a new profile, or select an existing profile to assign this wallet to.
Click **Create Profile**. The wallet is now assigned to your new profile.
## What's in a Profile
| Component | Details |
| --------------- | ----------------------------------------------------------- |
| Name | Customizable display name |
| Emoji | Optional icon for quick visual identification |
| Wallets | Multiple wallet addresses (unique per profile) |
| Social Accounts | Discord and Telegram usernames (one per platform) |
| Tags | Custom labels for categorization (e.g., "whale", "insider") |
## Add More Wallets
Open the wallet modal for any address and assign it to an existing profile instead of creating a new one. Select the profile from the dropdown, and the wallet is added immediately.
## Link Social Accounts
Find the profile in your profile list and click to open it.
In the Social Accounts section, enter a Discord or Telegram username.
Now you'll see their on-chain trades AND their alpha calls from Discord/Telegram together.
## Edit & Delete Profiles
* **Rename** - click the profile name to edit it inline.
* **Change emoji** - click the emoji next to the name to pick a new one.
* **Delete** - remove a profile entirely. Its wallets return to an unassigned state.
Each wallet can only belong to one profile. This ensures transaction tables always show the correct profile name next to each trade.
## Organize with Profile Lists
Your first profile automatically creates a default profile list. From there you can:
* **Create new lists** to group profiles by strategy (e.g., "Whales", "Smart Money", "Alpha Callers")
* **Rename or delete lists** to keep your workspace tidy
Back to the wallet tracking overview.
Bulk-import wallet addresses into your profiles.
Get alerts when tracked wallets make moves.
# Quick Start
Source: https://docs.shuriken.trade/shuriken-terminal/quick-start
Get set up and see your first alpha signals in minutes.
## Getting Started
Go to [app.shuriken.trade](https://app.shuriken.trade) and sign in with your **Telegram** account.
Once connected, you'll land on the Alpha tab.
To see signals from your Telegram groups or Discord servers, you need to add the Shuriken bot.
You must be the **owner** of the group or server to add the bot. If you're not an owner, ask your admin to add it for you.
**Discord users** β Make sure your Discord account is linked to the Terminal before adding the bot. Click the **Discord icon** in the top header bar, or go to **Profile > Integrations** to connect it. Without this, your server's feed won't appear.
**Telegram**
```
https://t.me/shuriken_alpha_bot?startgroup=botstart
```
After adding, send a message mentioning any token in the group, then connect it in the Terminal. [Full guide β](/shuriken-terminal/connect-telegram-bot)
**Discord**
```
https://discord.com/oauth2/authorize?client_id=1440745309775990794&permissions=8&integration_type=0&scope=bot
```
After inviting, activate the server in the Terminal. [Full guide β](/shuriken-terminal/connect-discord-bot)
Don't own a server or waiting for your admin to add the bot? You can still explore the platform.
**X Stream** gives you a curated feed of crypto Twitter accounts in real-time β no setup required.
Click the **X (Twitter) icon** in the left sidebar of your Alpha tab to open it. [Learn more β](/shuriken-terminal/x-stream)
Once your sources are connected, you'll start seeing alpha flow in. Signals let you filter this feed to show only what matters to you.
Ready to create your first signal? [Follow our step-by-step tutorial β](/shuriken-terminal/first-signal)
## Next Steps
Add advanced filters like market cap, liquidity, and token age.
Learn the trading interface and execute your first trade.
Build profiles for the traders you follow and track their on-chain moves.
# Referral Program
Source: https://docs.shuriken.trade/shuriken-terminal/referral-program
Earn rewards by referring traders and making alpha calls on Shuriken.
**Earn a percentage of trading fees from every user you refer to Shuriken.** The more traders you bring in and the more volume you generate, the higher your rewards.
## How It Works
Shuriken uses a multi-layer referral system. When someone signs up with your referral code and trades, you earn a share of the trading fees they generate. Your referrals' referrals also earn you rewards, up to three layers deep.
| Layer | Description |
| ------------------ | ----------------------------------------- |
| Direct (Layer 1) | Users who sign up with your referral code |
| Indirect (Layer 2) | Users referred by your direct referrals |
| Indirect (Layer 3) | Users referred by your Layer 2 referrals |
Each layer earns you a percentage of the trading fees generated by the users in that layer. The deeper the layer, the smaller the percentage, but the broader your network.
When a trade is attributed to an alpha call, the alpha caller and group owner earn the fee share instead of the referral chain. Alpha call rewards take priority over referral rewards for that trade, rewarding active contributors in the space.
## Accessing the Rewards Page
Click **Rewards** in the top navigation bar of the Shuriken Terminal to open your referral dashboard.
## Your Referral Code
Your unique referral code is displayed at the top of the Rewards page. You can:
* **Copy** your referral link to share anywhere
* **Share on X (Twitter)** using the built-in share button to post your referral link directly
When someone signs up through your link, they are permanently linked to your referral network.
## Tiers
Your tier determines the referral rate you earn. Tiers are based on a combination of your personal trading volume and the number of traders you recruit. You receive the higher of your tier-based referral rate or your fee schedule rate.
There are five levels, each with four sub-tiers that progressively unlock better referral rates and cashback percentages.
| Level | Tiers |
| ----------- | ----------------------------- |
| Trencher | Trencher 1, 2, 3, 4 |
| Platinum | Platinum 1, 2, 3, 4 |
| Diamond | Diamond 1, 2, 3, 4 |
| Master | Master 1, 2, 3, 4 |
| Grandmaster | Grandmaster 1, 2, 3, 4 |
| Partner | Invite-only with custom rates |
As you increase your trading volume and recruit more referrals, you advance through the sub-tiers within each level before moving up to the next level.
Higher tiers unlock better referral rates and cashback percentages. Your cashback rate can range from 5% up to 45% depending on your tier.
**Partner** is a special invite-only tier with custom referral rates and benefits. Contact the Shuriken team for details.
You can track your current tier and progress toward the next tier on the Rewards page.
## Claiming Rewards
Rewards accumulate per blockchain. To claim your earnings:
Click **Rewards** in the top navigation bar.
Click the **Claim** button next to your unclaimed rewards.
Choose the blockchain you want to claim from.
Enter the wallet address where you want to receive your rewards.
Rewards are paid in native tokens for each chain (e.g., SOL on Solana, ETH on Ethereum and Base, BNB on BSC).
## Alpha Caller Rewards
In addition to referral earnings, you can earn rewards when users trade based on alpha calls. This applies to both individual callers and group owners, making it a powerful way to generate passive income from your alpha community.
### How Alpha Caller Rewards Work
When a user executes a trade based on an alpha call made in a Shuriken-connected group, a share of the trading fees is distributed to the caller and the group owner. This happens automatically -- no referral link is needed.
### For Alpha Callers
If you make alpha calls (token mentions) in a connected Telegram group or Discord server, you earn a percentage of the trading fees generated when other users trade on those calls.
* Earn up to **30%** of trading fees from trades made on your calls
* Your alpha caller rate scales with your tier -- higher tiers earn a higher percentage
* Earnings are tracked per chain across both Solana and EVM networks
### For Group Owners
As a group owner with the Shuriken bot connected, you earn passive income whenever trades are executed based on alpha calls made within your group. The more active and high-quality your group's callers are, the more you earn.
* Earn **2% of net trading fees** generated from all calls in your group
* No action required beyond having the Shuriken bot connected to your group
* The more groups you connect, the broader your earning potential
* Track group performance through the [Analytics Dashboard](/shuriken-terminal/analytics-dashboard)
Adding the Shuriken bot to more groups increases your passive earning potential. Group owners with multiple active groups earn rewards from every trade driven by calls across all of their groups.
### Tracking Alpha Earnings
Alpha caller earnings are displayed separately from referral earnings under the **Alpha Calls Earnings** stat on the Rewards page. These rewards accumulate per chain and are claimed through the same process as referral rewards.
## Milestone Tracking
The Rewards page includes a milestone progress bar that tracks your journey toward earning goals. Use the potential earnings calculator to estimate your rewards based on your referral network size and trading volume.
Manage referrals through the Telegram Bot.
Get set up with the Shuriken Terminal.
Learn the trading interface and place your first trade.
See all supported blockchains for trading and rewards.
# Signal Conditions
Source: https://docs.shuriken.trade/shuriken-terminal/signal-conditions
Move beyond basic alerts by adding powerful filters for market cap, liquidity, token age, and more.
Signal Conditions are where the true power of the Alpha Platform comes to life. They allow you to filter out the noise and only get alerted on token mentions that match your exact criteria.
You can combine multiple conditions to create highly specific and powerful signals.
### Available Conditions
Filter tokens based on their fully diluted market cap. This is useful for finding tokens that are just starting to gain traction or ignoring already established large-cap tokens.
**Example:** Find low-cap gems by setting a range of `$5,000` to `$100,000`.
Filter tokens based on the amount of liquidity in their primary pool. This helps ensure that a token is tradable and can protect against low-liquidity scams.
**Example:** To avoid useless tokens, set a minimum liquidity of `$10,000`.
Filter tokens based on how long ago they were created. This is a powerful way to find brand new launches or focus on more established projects.
**Example:** To catch "fresh wallets," set a maximum age of `24 hours`.
Filter signals to only fire after a token has been mentioned a certain number of times within a specific time window. This helps identify tokens that are gaining social momentum.
**Example:** Alert only after a token is mentioned `3 times` in `60 minutes` within the same channel to find trending conversations.
Automatically disable a signal after it has fired a certain number of times. This is a safety feature to prevent a single, noisy signal from flooding your feed.
**Example:** Set `Max Fires` to `10` to automatically pause the signal after ten successful alerts.
By default, a signal will only fire **once every 24 hours for the same token**. This prevents you from getting spammed with alerts if the same token is mentioned repeatedly.
This is a built-in safety feature and is not currently configurable.
### Example: The "New & Trending" Signal
Let's combine these conditions to build a powerful signal that finds newly launched tokens that are starting to gain real traction.
* **Sources:** A selection of high-quality alpha channels.
* **Conditions:**
* **Token Age:** Less than `48 hours`.
* **Liquidity:** Between `$10,000` and `$50,000`.
* **Mention Frequency:** At least `3 mentions` within `1 hour`.
This signal will only alert you to tokens that are new, have enough liquidity to be viable, and are actively being discussed, filtering out 99% of the noise.
# Supported Chains
Source: https://docs.shuriken.trade/shuriken-terminal/supported-chains
Trade on Solana, Base, BSC, and Monad with chain-specific features and considerations.
**The Trading Terminal supports multiple blockchain networks.**
Each chain has unique characteristics that affect trading speed, fees, and available features.
Fast, low-fee transactions. The primary chain for most trading activity.
Fast, low-fee EVM chain with a rapidly growing ecosystem.
Binance Smart Chain. EVM-compatible with an established DeFi ecosystem.
EVM chain with an emerging ecosystem.
# Token Analytics
Source: https://docs.shuriken.trade/shuriken-terminal/token-analytics
View token statistics, holder data, and distribution metrics.
**Each token page displays key metrics and holder analysis.**
Use this data to evaluate tokens before trading.
## Token Statistics
The statistics panel shows:
| Metric | Description |
| ---------- | ---------------------------------- |
| Market Cap | Current fully diluted valuation |
| Liquidity | Total value in trading pools |
| Supply | Total and circulating token supply |
| Volume | Trading volume across timeframes |
## Top Holders
The Holders tab ranks wallets by token balance. Click any wallet address to view its recent activity β and [create a profile](/shuriken-terminal/profiles) to track it. Each wallet may have tags:
| Tag | Meaning |
| ---------- | ------------------------------------------ |
| Whale | Holds a large percentage of supply |
| Sniper | Bought within the first minute of launch |
| Pro Trader | Wallet with historically profitable trades |
| Freshie | Recently created wallet |
## Token Distribution
Distribution stats show how the token supply is spread:
* **Holder count**: Total number of wallets holding the token
* **Top 10%**: Percentage held by the top 10 holders
* **Dev balance**: Tokens held by deployer wallet
* **Sniper balance**: Tokens held by early buyers
* **Pro trader balance**: Tokens held by historically profitable wallets
## Alpha Tab
The Alpha tab shows historical calls for this token from your connected sources:
| Column | Description |
| ---------- | -------------------------------------------- |
| Caller | Who made the call |
| Time | When the call was made |
| Source | Discord server, Telegram group, or X account |
| MC at Call | Market cap when the call was made |
| Multiplier | Current price vs price at call |
# Trade Settings
Source: https://docs.shuriken.trade/shuriken-terminal/trade-settings
Configure slippage, priority fees, and MEV protection.
**Trade settings control how your transactions are executed.**
Adjust these based on market conditions and your trading needs.
## Slippage Tolerance
Slippage is the difference between the expected price and the actual execution price.
Higher slippage increases the chance your trade executes but may result in a worse price. Lower slippage protects your price but the trade may fail if the market moves.
## Priority Fee
Priority fees incentivize validators to include your transaction faster. During network congestion, higher fees help ensure execution.
* **Solana**: Priority fee is set in SOL. Increase it during congestion to improve confirmation speed.
* **EVM chains (Base, BSC, Monad)**: Priority fee is set in gwei. This works the same way β a higher gwei value means faster transaction inclusion.
## Anti-MEV Protection
MEV (Maximal Extractable Value) refers to profit extracted by reordering transactions. Sandwich attacks are a common form where attackers front-run and back-run your trade to profit from the price movement.
* **Enabled**: Transactions are routed to protect against sandwich attacks
* **Disabled**: Standard transaction routing
## Auto Mode
Use Auto mode if you don't want to configure your own settings.
# Trading Glossary
Source: https://docs.shuriken.trade/shuriken-terminal/trading-glossary
Common trading terms explained.
**Reference guide for trading terminology.**
Understanding these concepts will help you use the Trading Terminal effectively.
The total value of a token's supply. Calculated as: Price Γ Total Supply. Used to gauge a token's size relative to others.
The amount of funds available in a token's trading pools. Higher liquidity means you can buy or sell larger amounts without significantly moving the price.
The difference between the expected price and the actual execution price. Occurs because prices can change between when you submit a trade and when it confirms.
An order that executes immediately at the best available price. Prioritizes speed over price precision.
An order that only executes when price reaches your specified level. Waits for your target price.
A sell order placed above current price to automatically lock in gains when your target is reached.
A sell order placed below current price to automatically exit if price drops to limit your losses.
Profit extracted by reordering blockchain transactions. Sandwich attacks are a common form where attackers front-run and back-run trades.
Fee paid to validators to process your transaction. Higher fees typically result in faster confirmation.
A trading platform that operates without a central authority, using smart contracts to facilitate trades.
The gain or loss on a position. Calculated as current value minus your purchase cost.
# Wallet Signals
Source: https://docs.shuriken.trade/shuriken-terminal/wallet-signals
Tracked wallet transactions appear as signal cards in your feed - right alongside your alpha calls.
**Tracked wallet transactions appear as signal cards in your Recent Calls feed - right alongside your alpha group calls.**
## Wallet Activity in Your Feed
**Tracked Wallets** appears as a source in the [Recent Calls](/shuriken-terminal/interface-overview) sidebar alongside your Discord servers and Telegram groups. Click it to see a stream of all transactions from your tracked wallets.
Every buy, sell, and swap from your [tracked profiles](/shuriken-terminal/wallet-tracking) flows into the same feed you already monitor for social calls - no extra tabs or windows.
## Signal Cards
Wallet signal cards display:
* **Profile name and wallet address** - instantly identify who traded
* **Action and token** - buy, sell, or swap with the token name and contract
* **Amount** - the size of the transaction in SOL or the chain's native token
Each card includes the same token detail view as social calls - chart, stats, and quick-buy buttons. Wallet signal cards are visually distinct from social call cards, so you can tell the source at a glance.
## Profile Activity View
Click on any profile to see a detailed breakdown of their activity:
* **Wallet Activity tab** - Full on-chain transaction history across all wallets linked to the profile. See every buy, sell, and swap in chronological order.
* **Signal tab** - A combined view of on-chain wallet trades and off-chain social calls from Discord and Telegram. This is where linking social accounts to a profile pays off - you see the full picture of a caller's activity in one place.
## Trade Directly from Signals
Wallet signal cards support the same quick-buy flow as social call cards. Spot a tracked wallet scooping up a token, and buy it yourself in one click - no need to copy-paste contracts or switch to another tool.
Link a caller's Discord to their profile. Now when they post in your alpha group **and** their wallet buys the same token, you see both - on-chain conviction meets social calls.
Create and manage trader profiles with linked wallets and socials.
Bring your existing wallet lists from other platforms.
# Wallet Tracking
Source: https://docs.shuriken.trade/shuriken-terminal/wallet-tracking
Track the traders behind the wallets - profiles, profile lists, and real-time signals.
**Build a roster of every wallet and caller worth watching - and never lose track when they switch wallets.**
## Track People, Not Just Wallets
You're tracking 50 wallets on another platform. One of your best callers rotates to a new wallet - you don't notice for a week. With Shuriken, you track the *person*: all their wallets, their Discord, their Telegram - in one profile. When they rotate wallets, just add the new one. Their entire history stays connected.
## Key Concepts
* **Profile** - A contact card for a trader or entity. Holds wallets, social accounts, and tags.
* **Profile List** - A category for organizing profiles (e.g., "Whales", "Smart Money").
* **Wallet Signals** - Tracked wallet transactions that appear as signal cards in your Recent Calls feed.
## How It Works
1. Discover an interesting wallet in a transaction table
2. Click it and create a profile
3. Add more wallets, link their Discord/Telegram accounts
4. Their on-chain trades and social calls appear together in your feed
## Switching from Another Platform?
Already tracking wallets on Axiom, Padre, GMGN, Cielo, or Ray Bot? [Import your entire list in under a minute.](/shuriken-terminal/import-wallets) Everything transfers - names, groups, and organization. You lose nothing.
## Supported Chains
Wallet tracking is available on **Solana** and EVM chains (**Base**, **BSC**, **Monad**). All on-chain activity across these networks flows into a single unified feed.
## Get Started
Create and manage trader profiles with linked wallets and socials.
Bring your existing profile lists from other platforms.
Get real-time alerts when tracked wallets make moves.
# X Stream
Source: https://docs.shuriken.trade/shuriken-terminal/x-stream
Live Twitter/X feed integrated into the Shuriken Terminal showing curated crypto accounts in real-time.
**X Stream is your real-time window into Crypto Twitter.**
A curated feed of influential crypto accounts delivered directly to your Shuriken Terminal. No setup required, just open and start watching.
## Navigation
Access the X Stream from the **X (Twitter) icon** in the left sidebar of your Alpha Tab. A green **"Live"** indicator confirms you're receiving real-time updates.
Twitter calls also appear in the **Recent Calls** table alongside Discord and Telegram mentions. To hide Twitter calls from Recent Calls, click the **Twitter icon** in the table header to toggle them off.
X Stream operates separately from your main Alpha Feed. It's a dedicated view for Twitter/X content only. X Stream cannot be added to a Signal at this time.
## Feed Display
The X Stream displays tweets from a curated list of crypto accounts maintained by Shuriken. The feed is:
* **Real-time:** New tweets appear instantly at the bottom
* **Read-only:** The account list is curated and cannot be modified
* **Rich content:** Full tweet cards with profile picture, username, handle, verified badge, and timestamp
* **Media-enabled:** Images are embedded inline
# Exit Strategies
Source: https://docs.shuriken.trade/telegram-bot/exit-strategies
Automatically attach take profit and stop loss to your trades.
Exit strategies create limit orders automatically when you buy a token.
## How Exit Strategies Work
When you buy a token with an exit strategy enabled, the bot automatically creates take profit and stop loss orders based on your selected strategy.
* **Take Profit (TP)**: Sells a portion when price rises to target
* **Stop Loss (SL)**: Sells if price drops to limit
Exit strategies work with both manual buys and signal notification buys.
## Setting a Default Strategy
Send `/settings` to open the settings panel.
Select the Exit Strategy option.
Select from preset strategies or your custom templates.
Your default strategy applies to all future buys until you change it.
## Available Presets
| Preset | Take Profit | Stop Loss |
| ---------------- | ------------------- | ------------ |
| No Exit Strategy | None | None |
| Free Ride | 50% at 2x | None |
| 25% TP/SL | 25% gain | 25% loss |
| Risk Averse | None | 5% loss |
| Ladder Up | Scale at 2x, 3x, 5x | None |
| Tight Trailing | Trailing at peak | 10% trailing |
| Conservative | 50% gain | 15% loss |
| Moon or Bust | 10x target | 30% loss |
## Custom Templates
Custom automation templates you create in the Terminal appear in the exit strategy selection list. Create complex multi-step strategies in the Terminal, then use them from Telegram.
## Signal Notification Trades
When you tap **Buy** on a signal notification, your default exit strategy is automatically attached to the trade. This lets you enter positions quickly from alerts while maintaining your risk management rules.
Set a default exit strategy once, and every buy from signal notifications will have automatic TP/SL protection.
Configure your default exit strategy.
View and manage your active orders.
# Limit Orders
Source: https://docs.shuriken.trade/telegram-bot/limit-orders
Automate your trades with take profit, stop loss, and more.
Limit orders let you automate trades based on price conditions. Set your targets and the bot handles execution.
Limit orders are created in the [Shuriken Terminal](https://app.shuriken.trade). Use Telegram Bot to view and manage your active orders.
## Order Types
Automatically sell when the price rises to your target.
**Use case:** Lock in gains at a specific price point.
**Example:** Sell 50% of your position when the token reaches \$10M market cap.
Automatically sell when the price drops to your limit.
**Use case:** Protect against losses if the token dumps.
**Example:** Sell your entire position if the price drops 50% from entry.
Automatically buy when the price drops to your target.
**Use case:** Enter a position at a lower price.
**Example:** Buy when the token drops to \$5M market cap.
Automatically buy when the price rises above a threshold.
**Use case:** Enter on breakout or momentum confirmation.
**Example:** Buy when the token breaks above \$20M market cap.
## Viewing Orders
Access the Orders panel from the main menu to see all active limit orders.
Each order displays:
| Field | Description |
| ---------- | --------------------------------------------- |
| Order Type | Take Profit, Stop Loss, Buy Dip, or Buy Above |
| Token | The token symbol |
| Target | Your target price or market cap |
| Current | Current price with percentage from target |
| Amount | Token amount and wallet name |
| Chain | SOL, BSC, or MON indicator |
## Cancelling Orders
To cancel an active order:
Navigate to the Orders panel from the main menu.
Below the order list, you'll see cancel buttons for each order labeled with the token symbol and order type (e.g., "DO (SL)" for a Stop Loss on DO token).
Tap the cancel button matching the order you want to remove. The order is cancelled immediately.
## Notifications
When a limit order triggers, you'll receive a notification with:
| Status | Description |
| --------- | ---------------------------------------- |
| Triggered | Order conditions met, executing trade |
| Success | Trade completed successfully |
| Failed | Trade execution failed |
| Cancelled | Order was manually cancelled |
| Expired | Order expired before conditions were met |
# Notifications
Source: https://docs.shuriken.trade/telegram-bot/notifications
Stay informed with real-time trade and signal alerts.
The Telegram Bot sends notifications for signals, trades, and limit orders.
## Signal Notifications
When a token matches your alpha signal conditions, you receive a notification with:
* Token card showing price, market cap, and liquidity
* Quick buy buttons (0.1, 0.5, 1, 2, 5 SOL/BNB)
* Number of mentions from your connected alpha sources
Buys from signal notifications automatically attach your default exit strategy for instant TP/SL protection.
## Swap Notifications
After a buy or sell executes, you receive a concise confirmation with:
* Token symbol and amount
* Transaction status (success or failed)
* Link to view transaction
## Limit Order Notifications
When limit orders trigger, you're notified of the status:
| Status | Description |
| --------- | ---------------------------------------- |
| Triggered | Order conditions met, executing trade |
| Success | Order filled successfully |
| Failed | Trade execution failed |
| Cancelled | Order was manually cancelled |
| Expired | Order expired before conditions were met |
Set up automatic TP/SL on your trades.
View and manage your active orders.
# Overview
Source: https://docs.shuriken.trade/telegram-bot/overview
Trade tokens directly from Telegram with multi-chain support.
**Telegram Bot is Shuriken's Telegram trading interface.**
Buy and sell tokens on Solana, BSC, and Monad without leaving Telegram. Manage wallets, track positions, and execute trades in seconds.
## Core Features
The Telegram Bot includes:
* **Market Orders**: Buy and sell tokens at current market prices
* **Limit Orders**: Set take profit, stop loss, and conditional buys
* **Exit Strategies**: Auto-attach TP/SL to every trade
* **Wallet Management**: Create, import, and switch between wallets
* **Position Tracking**: Monitor holdings and PnL across all chains
* **Referral Program**: Earn rewards by inviting friends
* **Multi-Chain Support**: Trade on Solana, BSC, and Monad from one bot
Buy and sell tokens with real-time market data.
Auto-attach take profit and stop loss to trades.
Create, import, and manage wallets for each chain.
Earn rewards by inviting friends to trade.
## Terminal Integration
Telegram Bot connects directly to your Shuriken Terminal account. Your wallets sync between both platforms, so you can manage them in the Terminal and trade from Telegram when you're on the go.
**Use both platforms together.** Manage your wallets and analyze tokens in the Terminal, then execute quick trades from Telegram when you spot an opportunity.
# Positions
Source: https://docs.shuriken.trade/telegram-bot/positions
Track your token holdings and PnL across all chains.
The Positions panel shows all your token holdings in one place, grouped by chain.
## Viewing Positions
Send `/positions` to open your positions panel.
## Understanding the Display
Your positions are organized by chain:
| Chain | Indicator |
| ------ | --------- |
| Solana | SOL |
| BSC | BSC |
| Monad | MON |
Each position shows:
| Field | Description |
| ------------ | ---------------------------------------- |
| Token Symbol | The token ticker |
| Value | Current USD value |
| PnL | Profit or loss percentage since purchase |
## Quick Actions
Opens the token card where you can view market data, buy more, or sell your position.
View your entry market cap, current value, cost basis, PnL, and number of buys and sells.
Check your positions regularly to monitor PnL and make informed trading decisions.
# Quick Start
Source: https://docs.shuriken.trade/telegram-bot/quick-start
Make your first trade in under 5 minutes.
This guide walks you through your first trade using Telegram Bot.
You'll need a Shuriken account to use Telegram Bot. If you don't have one yet, you can create it during the setup process.
## Your First Trade
Open [@shuriken\_trade\_bot](https://t.me/shuriken_trade_bot) in Telegram and tap **Start** or send `/start`.
If prompted, follow the instructions to link your Telegram to your Shuriken account. This is a one-time setup.
Navigate to the Wallets panel. Select **Solana** or **EVM** (for BSC and Monad), then tap **Create Wallet**.
Creating an EVM wallet gives you access to both BSC and Monad chains.
Tap your new wallet to view the deposit address. Send funds from an exchange or another wallet.
Paste a token contract address directly into the chat. The bot will display a token card with market data.
Tap **Buy** on the token card. Select a preset amount or enter a custom value. If you have multiple wallets, select which one to use.
Review the trade details and tap **Confirm**. Once the transaction completes, you'll see a confirmation message.
Congratulations! You've made your first trade. View your new position using the `/positions` command.
## Next Steps
Learn how to import existing wallets and manage multiple chains.
Explore buying, selling, and token information features.
# Referrals
Source: https://docs.shuriken.trade/telegram-bot/referrals
Earn rewards by inviting friends to trade.
Earn a percentage of trading fees from users you refer to Shuriken.
## Accessing Referrals
Send `/referrals` or tap **Referrals** from the home menu to view your referral dashboard.
## Your Referral Link
Your unique referral link:
```
https://t.me/shuriken_trade_bot?start=ref-YOURCODE
```
Share this link with friends. When they sign up and trade, you earn rewards.
## Referral Dashboard
The referrals panel displays:
| Field | Description |
| ----------------- | ----------------------------------------- |
| Referral Link | Your unique link to share |
| Net Referral Rate | Your commission percentage per layer |
| Active Referrals | Number of direct referrals (Layer 1) |
| Cashback Tier | Your current tier and rate |
| Unclaimed Rewards | Pending rewards by chain (SOL, BSC, etc.) |
| Lifetime Rewards | Total rewards earned |
## Claiming Rewards
Rewards accumulate per chain. To claim:
Send `/referrals` to view your dashboard.
Choose the chain you want to claim from (SOL, BSC, etc.).
Tap claim to receive your rewards.
Rewards are paid in native tokens for each chain.
Start trading to earn cashback.
Get started with the Telegram Bot.
View the full referral program details in the Trading Terminal docs.
# Settings
Source: https://docs.shuriken.trade/telegram-bot/settings
Configure trading preferences and bot behavior.
Access your settings by sending `/settings` in the bot.
## Trade Settings
The settings panel displays your current configuration:
* **Degen Mode**: Shows ON or OFF status
* **Exit Strategy**: Shows your selected strategy (e.g., "Moon or Bust")
## Degen Mode
Degen Mode removes the confirmation step from trades for faster execution.
| Mode | Flow |
| ------ | --------------------------------------------- |
| Normal | Select amount β Review confirmation β Execute |
| Degen | Select amount β Execute immediately |
Tap **Disable Degen Mode** or **Enable Degen Mode** to toggle.
With Degen Mode enabled, trades execute instantly after selecting an amount. Double check your values before tapping Buy or Sell.
## Exit Strategy
Tap **Configure Exit Strategy** to set a default strategy that automatically attaches take profit and stop loss orders to your buys.
| Preset | Description |
| ---------------- | -------------------------------- |
| No Exit Strategy | No automatic orders (default) |
| Free Ride | Take 50% at 2x, let rest ride |
| 25% TP/SL | 25% profit target, 25% stop loss |
| Risk Averse | Tight 5% stop loss protection |
| Ladder Up | Scale out at 2x, 3x, 5x |
| Tight Trailing | Trailing stop at -10% |
| Conservative | 50% profit, 15% stop loss |
| Moon or Bust | Hold for 10x or -30% |
Custom automation templates created in the Terminal also appear in this list.
## Swap Settings
Tap **Configure Swap Settings** to adjust parameters for market orders like slippage tolerance and priority fees.
## Order Settings
Tap **Configure Order Settings** to customize default values for limit orders.
Learn more about how exit strategies work.
Buy and sell tokens with the bot.
# Trading
Source: https://docs.shuriken.trade/telegram-bot/trading
Buy and sell tokens with real-time market data.
Telegram Bot lets you buy and sell tokens on Solana, BSC, and Monad directly from Telegram.
## Finding Tokens
There are two ways to find tokens:
Copy a token's contract address and paste it directly into the chat.
Tap Buy on signal notifications to enter positions with your default exit strategy attached.
## Token Card
When you find a token, Telegram Bot displays a token card with key market data.
| Data | Description |
| ------------- | ------------------------------------------------------ |
| Market Cap | Market capitalization |
| Price | Current token price |
| Liquidity | Available liquidity |
| Bonding Curve | Bonding status |
| Mentions | Number of social mentions from connected alpha sources |
**Want to see social mentions?**
Mentions show how many times a token has been called across your connected alpha sources. To see this data, you need to be part of communities that have set up the Alpha Platform.
Learn how to invite the bot to your servers.
Connect custom alpha sources via webhook.
## Buying Tokens
Paste a contract address or tap a token from a signal to view its card.
Tap the **Buy** button on the token card.
Choose from preset amounts or enter a custom value.
If you have multiple wallets, select which one to use for this trade.
Review the trade details and tap **Confirm** to execute.
Your position will appear in the `/positions` panel once the transaction completes.
## Selling Tokens
You can sell tokens from the token card or from your positions panel.
### From Token Card
Open the token card for the token you want to sell.
Tap the **Sell** button.
Choose a quick percentage (25%, 50%, 100%) or enter a custom amount.
Review and confirm the sale.
### From Positions
Send `/positions` to view your holdings.
Tap the token you want to sell.
Choose your sell amount and confirm.
Use the 100% quick sell option to close a position completely.
# Wallet Management
Source: https://docs.shuriken.trade/telegram-bot/wallet-management
Create, import, and manage wallets for Solana, BSC, and Monad.
Telegram Bot supports multiple wallets across different chains. Manage all your wallets from the Wallets panel.
## Viewing Your Wallets
Access the Wallets panel from the main menu or by sending `/start`. Your wallets are grouped by chain:
| Chain | Network Type |
| ------ | ------------ |
| Solana | SVM |
| BSC | EVM |
| Monad | EVM |
Each chain displays the aggregate balance across all wallets.
## Creating a Wallet
Navigate to the Wallets panel from the main menu, or use the `/wallets` command.
Choose **Solana** for SVM or **EVM** for BSC and Monad.
Creating an EVM wallet gives you access to both BSC and Monad chains with the same wallet.
Tap **Create Wallet**. Your new wallet will appear in the list with its deposit address.
## Importing a Wallet
Bring an existing wallet into Telegram Bot using its private key.
Navigate to the Wallets panel from the main menu, or use the `/wallets` command.
Choose the chain type that matches your wallet (Solana or EVM).
Tap **Import Wallet** and paste your private key when prompted. The wallet will be added to your account.
Never share your private key with anyone. Shuriken staff will never ask for your private key.
## Exporting a Private Key
You can export the private key of any wallet created in Telegram Bot.
From the Wallets panel, tap the wallet you want to export.
Tap **Export** to reveal the private key.
Copy the key and store it in a secure location.
Your private key grants full access to your wallet. Store it offline and never share it.
## Deleting a Wallet
Remove a wallet from Telegram Bot when you no longer need it.
Before deleting, transfer any remaining funds to another wallet.
From the Wallets panel, tap the wallet you want to delete.
Tap **Delete** and confirm when prompted.
Deleting a wallet removes it from Telegram Bot. Shuriken does not store your private keys. It is your responsibility to export and securely store them before deleting.