Skip to content
Skills Library
Programming · Tool integration

api-integration

/api-integration

Use when a user wants to integrate with or develop against the Shuriken API or SDK — covers proficiency assessment, path routing (quickstart / raw API / SDK), and tells you which deepening reference tool to reach for (OpenAPI for HTTP endpoints, the stream catalog for WebSockets, platform docs as fallback).

Licence
MIT
Last repository change
11.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
9
Deprecation

No signals detected. Repository changed on 11.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when a user wants to integrate with or develop against the Shuriken API or SDK — covers proficiency assessment, path routing (quickstart / raw API / SDK), and tells you which deepening reference tool to reach for (OpenAPI for HTTP endpoints, the stream catalog for WebSockets, platform docs as fallback).

Original author description

Use when a user wants to integrate with or develop against the Shuriken API or SDK — covers proficiency assessment, path routing (quickstart / raw API / SDK), and tells you which deepening reference tool to reach for (OpenAPI for HTTP endpoints, the stream catalog for WebSockets, platform docs as fallback).

How it works

  1. Phase 1 — orient before writing anything
  2. Phase 2 — deepen only when the question demands it
  3. Best practices
  4. When to ask clarifying questions
  5. Pointers
Original SKILL.md headings · 70 lines, 636 words
SKILL.md preview
---
name: api-integration
description: Use when a user wants to integrate with or develop against the Shuriken API or SDK — covers proficiency assessment, path routing (quickstart / raw API / SDK), and tells you which deepening reference tool to reach for (OpenAPI for HTTP endpoints, the stream catalog for WebSockets, platform docs as fallback).
---

# Integrating and building with Shuriken

This skill covers the full "I want to call Shuriken programmatically" surface. It is intentionally thin up front — use the deepening tools below rather than pasting long code into the session.

## Phase 1 — orient before writing anything

Before pointing the user at code, establish two things:

### 1. Technical proficiency

- **Absolute beginner.** New to programming, or scripting at the level of "I can run a CLI if someone tells me exactly what to type." Needs hand-holding, copy-pasteable examples, environment setup spelled out.
- **Intermediate / power user.** Comfortable with a terminal, editing configs, running scripts. Will follow a README but gets stuck on non-obvious toolchain setup.
- **Software engineer.** Fluent in at least one language, reads types and API surfaces, skims READMEs and dives into code. Wants reference material, not prose.

Calibrate vocabulary and level of detail to this. If ambiguous, ask one clarifying question before firing off a long answer.

### 2. Integration path

Three ways to call Shuriken. Help the user pick.

- **Quickstart template** — pre-wired project scaffold with runnable examples. Supply an agent key via env var and things work out of the box. Best for beginners, intermediates, demos, and first-time evaluations.
  - TypeScript: https://github.com/ShurikenTrade/shuriken-quickstart-ts
  - Rust: https://github.com/ShurikenTrade/shuriken-quickstart-rs
- **Direct SDK integration** — add the SDK as a dependency to an existing project and wire it yourself. Best for software engineers comfortable with the surface, existing codebases, and library authors.
  - TypeScript SDK: https://github.com/ShurikenTrade/shuriken-sdk-ts
  - Rust SDK: https://github.com/ShurikenTrade/shuriken-sdk-rs
- **Raw HTTP / WebSocket** — call the API directly without an SDK. Best when the user's language isn't covered by an SDK, or when they have strong reasons to avoid pulling in a dependency.

Rough default: quickstart for beginners/intermediates, SDK for software engineers, raw HTTP only when they've said why.

### 3. Agent key

Every integration needs an agent key. See `shuriken:agent-keys` for lifecycle and `shuriken:scoping` for least-privilege scope selection. Point the user at [app.shuriken.trade/agents](https://app.shuriken.trade/agents) to create one.

## Phase 2 — deepen only when the question demands it

Do **not** preload the entire API reference into the conversation. Pull deeper references only when the user's next question needs them:

- **HTTP endpoint questions** ("what fields does /v1/foo return", "is there an endpoint for X", schema/signature questions) → call `fetch_shuriken_openapi`. This returns the live OpenAPI spec — the source of truth for HTTP endpoints.
- **WebSocket / streaming questions** ("what streams exist", "how do I subscribe to X", "what filters does this channel take") → call `fetch_shuriken_streams`. This returns the live v1 stream catalog with channel names, required filters, and payload formats.
- **Anything not answered by the two above** (guides, conceptual overviews of how a feature works, SDK-specific how-tos) → fall back to `fetch_shuriken_docs` and read the relevant page under `llms.txt`.

Never guess an endpoint or stream name from memory — the API evolves.

## Best practices

- **Use agent keys, not raw session tokens.** See `shuriken:agent-keys`.
- **Request only the scopes you need.** See `shuriken:scoping`.
- **Honour rate limits.** Back off on 429; the response headers tell you the retry window.
- **Don't poll when you can subscribe.** For live data, use the streams over repeated REST polls. Consult the stream catalog first.
- **Branch on structured error codes**, not message text. The API returns machine-readable error codes — see the OpenAPI spec for the taxonomy.

## When to ask clarifying questions

Before writing code, confirm:

- Technical proficiency level (see above).
- Which chain(s) the user is integrating against (Solana, EVM L1s, Base, BSC, Monad — support matrix varies).
- Deployment shape (one-off script, long-running service, serverless function).
- Integration path (quickstart / SDK / raw).

## Pointers

- TypeScript SDK: https://github.com/ShurikenTrade/shuriken-sdk-ts
- Rust SDK: https://github.com/ShurikenTrade/shuriken-sdk-rs
- TypeScript quickstart: https://github.com/ShurikenTrade/shuriken-quickstart-ts
- Rust quickstart: https://github.com/ShurikenTrade/shuriken-quickstart-rs
- Related skills: `shuriken:agent-keys`, `shuriken:scoping`, `shuriken:learn-about-shuriken`

Versions

RepositoryScoreLicence
This page · shurikentrade/shuriken-skills100MIT
facebook/agentic-tools100MIT
mhmdelgazzar/agentex100MIT
AutumnsGrove/Lattice100AGPL-3.0
srstomp/pokayokay100MIT
ajyadav013/claude-kit100MIT
ajyadav013/claude-kit100MIT
seb1n/awesome-ai-agent-skills100MIT
LambdaTest/agent-skills95MIT

Database snapshot: 13.11.2026 · package version 05a5ec4746b7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90learn-about-shuriken
    Use when a user asks conceptual questions about Shuriken — what it does, what features exist, how a feature works, or "what is X on Shuriken?" Does not cover programmatic integration (that's `shuriken:api-integration`).
  • 100api-docs
    Write reference documentation or an OpenAPI spec for a REST/HTTP API by reading its source code. Use when the user says "document the API", "write endpoint docs", "generate an OpenAPI/Swagger spec", "what endpoints do we have", or "document this route".
  • 100http-api-cloudbase
    CloudBase official HTTP API client guide. This skill should be used when backends, scripts, or non-SDK clients must call CloudBase platform APIs over raw HTTP instead of using a platform SDK or MCP management tool.
  • 95youdotcom-api
    Integrate You.com APIs (Research, Search, Contents) into any language using direct HTTP calls — no SDK required. - MANDATORY TRIGGERS: YDC API, You.com API integration, ydc-api, direct API integration, no SDK, Research API, youdotcom API, you.com REST API - Use when: developer…
  • 100docs-dev-hub-api-reference
    Use when a developer asks how to integrate with the platform API, authenticate requests, call specific endpoints, handle webhooks, or manage rate limits. This is a platform documentation skill covering the REST and streaming API, SDK installation, authentication, versioning,…
  • 100http-api-cloudbase
    CloudBase official HTTP API client guide. This skill should be used when backends, scripts, or non-SDK clients must call CloudBase platform APIs over raw HTTP instead of using a platform SDK or MCP management tool.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.