Loading skill
Install any skill in seconds. Free to start, no credit card required.
Get Started Free →Quicknode blockchain infrastructure for 80+ chains: Core RPC API, Streams, Webhooks, Blazar WSS, Solana gRPC, HyperCore gRPC, SQL Explorer, Metaplex DAS API, Blockbook, Ordinals & Runes API, Swap API, x402, MPP, Agent Subscriptions, CLI, and MCP.
SkillScore92/100
Test results 92
3/3 safety checks passed
25%92%of test cases passed +67 pts
Passed 22 of 24 test cases with the skill, and 6 of 24 without it.
16 fixed6 passed either way2 still failing0 broke
One test taskGive the exact terminal command to add the Quicknode MCP server to Claude Code using HTTP transport.
Adds every file the skill has, pinned so you can update it. No account needed.
pip install "decimalai>=0.15"
decimalai skills add internet-court-quicknode-skill
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"The same install from Python, for a notebook or a setup script.
pip install "decimalai>=0.15"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
print("Added. Start Claude Code with the command below.")claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.
/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai/decimalai:install internet-court-quicknode-skillThe plugin needs python3 and curl on your machine.
No Python or account. Claude Code picks it up in its next session.
curl -fsSL --create-dirs -o .claude/skills/internet-court-quicknode-skill/SKILL.md https://app.decimal.ai/s/internet-court-quicknode-skill/SKILL.md.claude/skills/internet-court-quicknode-skill/SKILL.mdThis gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[claude-agent-sdk]"
decimalai skills add internet-court-quicknode-skillimport asyncio
from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
async def main():
question = "Hello!"
async with support.run(question) as run: # one user message, one run
async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
print(message)
# In a notebook or async code: await main()
asyncio.run(main())Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[claude-agent-sdk]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
import asyncio
from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
async def main():
question = "Hello!"
async with support.run(question) as run: # one user message, one run
async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
print(message)
# In a notebook or async code: await main()
asyncio.run(main())Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdimport asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)
async def main():
async for message in query(prompt="Hello!", options=options):
print(message)
# In a notebook or async code: await main()
asyncio.run(main())This gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai-agents]"
decimalai skills add internet-court-quicknode-skillfrom agents import Agent, Runner
from decimalai.openai_agents import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
name=support.name,
instructions=support.instructions, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai-agents]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
from agents import Agent, Runner
from decimalai.openai_agents import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
name=support.name,
instructions=support.instructions, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from agents import Agent, Runner
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")This gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai]"
decimalai skills add internet-court-quicknode-skillimport json
from openai import OpenAI
from decimalai.openai import agent_config
client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
# run.system is your prompt, then the skill list.
messages = [{"role": "system", "content": run.system}, run.message]
while True:
reply = client.chat.completions.create(
model="gpt-5.4-mini",
messages=messages,
tools=[*TOOLS, *run.tools], # your tools, then load_skill
).choices[0].message
messages.append(reply)
if not reply.tool_calls:
break
for call in reply.tool_calls:
# load_skill is answered by the run; your own tools by FUNCTIONS.
function = FUNCTIONS.get(call.function.name)
messages.append(run.tool_result(call) or {
"role": "tool", "tool_call_id": call.id,
"content": function(**json.loads(call.function.arguments)) if function
else f"There is no tool named {call.function.name!r}.",
})
print(reply.content)
# The Responses API takes run.response_tools instead of run.tools.The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[openai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
import json
from openai import OpenAI
from decimalai.openai import agent_config
client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
# run.system is your prompt, then the skill list.
messages = [{"role": "system", "content": run.system}, run.message]
while True:
reply = client.chat.completions.create(
model="gpt-5.4-mini",
messages=messages,
tools=[*TOOLS, *run.tools], # your tools, then load_skill
).choices[0].message
messages.append(reply)
if not reply.tool_calls:
break
for call in reply.tool_calls:
# load_skill is answered by the run; your own tools by FUNCTIONS.
function = FUNCTIONS.get(call.function.name)
messages.append(run.tool_result(call) or {
"role": "tool", "tool_call_id": call.id,
"content": function(**json.loads(call.function.arguments)) if function
else f"There is no tool named {call.function.name!r}.",
})
print(reply.content)
# The Responses API takes run.response_tools instead of run.tools.No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from openai import OpenAI
client = OpenAI()
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
reply = client.chat.completions.create(
model="gpt-5.4-mini",
messages=[
{"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
{"role": "user", "content": "Hello!"},
],
).choices[0].messageThis gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[anthropic]"
decimalai skills add internet-court-quicknode-skillimport anthropic
from decimalai.anthropic import agent_config
client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
question = "Hello!"
with support.run(question) as run: # one user message, one run
answer = client.beta.messages.tool_runner(
model="claude-haiku-5-5",
max_tokens=4096,
system=run.system, # your prompt, then the skill list
tools=[*run.tools], # your tools, then load_skill
messages=[{"role": "user", "content": question}],
).until_done()The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[anthropic]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
import anthropic
from decimalai.anthropic import agent_config
client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
question = "Hello!"
with support.run(question) as run: # one user message, one run
answer = client.beta.messages.tool_runner(
model="claude-haiku-5-5",
max_tokens=4096,
system=run.system, # your prompt, then the skill list
tools=[*run.tools], # your tools, then load_skill
messages=[{"role": "user", "content": question}],
).until_done()No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
import anthropic
client = anthropic.Anthropic()
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
reply = client.messages.create(
model="claude-haiku-5-5",
max_tokens=4096,
system=f"You are a helpful agent.\n\n{skill}",
messages=[{"role": "user", "content": "Hello!"}],
)This gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[google-genai]"
decimalai skills add internet-court-quicknode-skillfrom google import genai
from google.genai import types
from decimalai.google_genai import agent_config
client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
config = types.GenerateContentConfig(
system_instruction=run.system, # your prompt, then the skill list
tools=[*TOOLS, *run.tool_params], # your functions, then load_skill
)
contents = [{"role": "user", "parts": [{"text": run.message}]}]
while True:
response = client.models.generate_content(
model="gemini-3.5-flash", contents=contents, config=config,
)
if not response.function_calls:
break
contents.append(response.candidates[0].content)
parts = []
for call in response.function_calls:
# load_skill is answered by the run; your own functions by FUNCTIONS.
# A loop of your own rather than automatic function calling, which
# raises KeyError when the model asks for a function you did not pass.
function = FUNCTIONS.get(call.name)
parts.append(run.tool_result(call) or {"function_response": {
"name": call.name, "id": call.id,
"response": {"result": function(**(call.args or {})) if function
else f"There is no function named {call.name!r}."},
}})
contents.append({"role": "user", "parts": parts})
print(response.text)The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[google-genai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
from google import genai
from google.genai import types
from decimalai.google_genai import agent_config
client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
def lookup_order(order_id: str) -> str:
return f"Order {order_id} shipped yesterday."
# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
"name": "lookup_order",
"description": "Look up the status of an order.",
"parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}
question = "Where is order A1001?"
with support.run(question) as run: # one user message, one run
config = types.GenerateContentConfig(
system_instruction=run.system, # your prompt, then the skill list
tools=[*TOOLS, *run.tool_params], # your functions, then load_skill
)
contents = [{"role": "user", "parts": [{"text": run.message}]}]
while True:
response = client.models.generate_content(
model="gemini-3.5-flash", contents=contents, config=config,
)
if not response.function_calls:
break
contents.append(response.candidates[0].content)
parts = []
for call in response.function_calls:
# load_skill is answered by the run; your own functions by FUNCTIONS.
# A loop of your own rather than automatic function calling, which
# raises KeyError when the model asks for a function you did not pass.
function = FUNCTIONS.get(call.name)
parts.append(run.tool_result(call) or {"function_response": {
"name": call.name, "id": call.id,
"response": {"result": function(**(call.args or {})) if function
else f"There is no function named {call.name!r}."},
}})
contents.append({"role": "user", "parts": parts})
print(response.text)No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from google import genai
from google.genai import types
client = genai.Client()
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
response = client.models.generate_content(
model="gemini-3.5-flash",
contents="Hello!",
config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)This gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[langchain]" langchain-openai
decimalai skills add internet-court-quicknode-skillfrom langchain.agents import create_agent
from decimalai.langchain import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = create_agent(
"openai:gpt-5.4-mini",
tools=[], # your tools; the middleware adds load_skill
middleware=[support.middleware], # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[langchain]" langchain-openaifrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
from langchain.agents import create_agent
from decimalai.langchain import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = create_agent(
"openai:gpt-5.4-mini",
tools=[], # your tools; the middleware adds load_skill
middleware=[support.middleware], # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from langchain.agents import create_agent
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})This gets SKILL.md only. The skill's 23 other files are not included.
CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add internet-court-quicknode-skillimport decimalai.crewai
from crewai import Agent, Crew, Task
agent = Agent(
role="Support", goal="Help the customer", backstory="A support agent.",
llm=llm, # your own CrewAI LLM
skills=decimalai.crewai.skills(), # the installed folder
tools=decimalai.crewai.skill_tools(), # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" "crewai>=1.15.27"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
import decimalai.crewai
from crewai import Agent, Crew, Task
agent = Agent(
role="Support", goal="Help the customer", backstory="A support agent.",
llm=llm, # your own CrewAI LLM
skills=decimalai.crewai.skills(), # the installed folder
tools=decimalai.crewai.skill_tools(), # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from crewai import Agent, Crew, Task
agent = Agent(
role="Support", goal="Help the customer", backstory="A support agent.",
llm=llm, # your own CrewAI LLM
skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()This gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[adk]"
decimalai skills add internet-court-quicknode-skillfrom decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = LlmAgent(
name="support", # ADK needs a Python identifier
model="gemini-3.5-flash",
instruction=support.instruction, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[adk]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = LlmAgent(
name="support", # ADK needs a Python identifier
model="gemini-3.5-flash",
instruction=support.instruction, # your prompt, then the skill list
tools=[*support.tools], # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from google.adk.agents import LlmAgent
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = LlmAgent(
name="support",
model="gemini-3.5-flash",
instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)This gets SKILL.md only. The skill's 23 other files are not included.
agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[pydantic-ai]"
decimalai skills add internet-court-quicknode-skillfrom pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
"openai:gpt-4o-mini",
name=support.name,
tools=[], # your tools; the capability adds load_skill
capabilities=[support], # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.
The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.
pip install "decimalai[pydantic-ai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")
agent = Agent(
"openai:gpt-4o-mini",
name=support.name,
tools=[], # your tools; the capability adds load_skill
capabilities=[support], # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from pydantic_ai import Agent
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")This gets SKILL.md only. The skill's 23 other files are not included.
Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" deepagents
decimalai skills add internet-court-quicknode-skillimport decimalai.deepagents
from deepagents import create_deep_agent
agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).
The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" deepagentsfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
import decimalai.deepagents
from deepagents import create_deep_agent
agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from deepagents import create_deep_agent
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})This gets SKILL.md only. The skill's 23 other files are not included.
Its own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" agent-framework
decimalai skills add internet-court-quicknode-skillimport asyncio
from agent_framework import Agent
from decimalai.agent_framework import skills
agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))It caches skills by default, so restart the process after decimalai skills update.
The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" agent-frameworkfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
import asyncio
from agent_framework import Agent
from decimalai.agent_framework import skills
agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))It caches skills by default, so restart the process after decimalai skills update.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdimport asyncio
from pathlib import Path
from agent_framework import Agent
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))This gets SKILL.md only. The skill's 23 other files are not included.
Strands' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" strands-agents
decimalai skills add internet-court-quicknode-skillfrom decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell
agent = Agent(
model=model, # always pass one: the default is Amazon Bedrock
system_prompt="You are a helpful agent.",
tools=[file_editor, shell],
plugins=[skills()],
)
agent("Hello!")Strands loads an agent's skills once, so build the agent again after decimalai skills update.
The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" strands-agentsfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("internet-court-quicknode-skill")
if result.exit_code:
raise SystemExit(result.problems)
from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell
agent = Agent(
model=model, # always pass one: the default is Amazon Bedrock
system_prompt="You are a helpful agent.",
tools=[file_editor, shell],
plugins=[skills()],
)
agent("Hello!")Strands loads an agent's skills once, so build the agent again after decimalai skills update.
No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.
.agents/skills/internet-court-quicknode-skill/SKILL.mdfrom pathlib import Path
from strands import Agent
skill = Path(".agents/skills/internet-court-quicknode-skill/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")This gets SKILL.md only. The skill's 23 other files are not included.
Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.
pip install "decimalai>=0.15"
decimalai skills add internet-court-quicknode-skillNo Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.
curl -fsSL --create-dirs -o .agents/skills/internet-court-quicknode-skill/SKILL.md https://app.decimal.ai/s/internet-court-quicknode-skill/SKILL.md.agents/skills/internet-court-quicknode-skill/SKILL.mdThis gets SKILL.md only. The skill's 23 other files are not included.
Give its text to your model as instructions. No account or package needed.
This gets SKILL.md only. The skill's 23 other files are not included.
Raw files: /s/internet-court-quicknode-skill/SKILL.md · /s/internet-court-quicknode-skill.json
Fetch the file and give its text to your model as instructions. No account or package needed.
curl -fsSL https://app.decimal.ai/s/internet-court-quicknode-skill/SKILL.mdcurl -fsSL https://app.decimal.ai/s/internet-court-quicknode-skill.jsonThis gets SKILL.md only. The skill's 23 other files are not included.
You don't need a DecimalAI account.
Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.
Claude Code reads files from your project, so DecimalAI config does not apply there.
On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.
On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.
On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.
On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.
On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.
Editors read files from your project, so DecimalAI config does not apply there.
Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.
QUICKNODE_RPC_URL, optional QUICKNODE_WSS_URL / QUICKNODE_API_KEY)?| Product | Description | Use Case |
|---|---|---|
| Core RPC API | High-performance blockchain access for 80+ chains | dApp backend, wallet interactions |
| Dedicated Clusters | Dedicated private node clusters | High-throughput production, compliance isolation |
| IPFS | Decentralized file storage | NFT metadata, asset hosting |
| Product | Description | Use Case |
|---|---|---|
| Streams | Real-time & historical blockchain data pipelines | Event monitoring, analytics, indexing |
| Streams Backfills | On-demand historical data backfill into Streams | Gap recovery, historical re-indexing |
| Webhooks | Event-driven notifications | Alerts, transaction monitoring |
| Solana gRPC | Solana Geyser streaming — included on Scale/Business, add-on on Build/Accelerate | Real-time account, transaction, slot data |
| Blazar WSS | Quicknode-built Solana WebSocket engine — all plans, free | Fast block, account, transaction, and slot subscriptions |
| HyperCore gRPC | gRPC streaming for Hyperliquid L1 — included on all paid plans | Trades, order book diffs, events, blocks in real time |
| Product | Description | Use Case |
|---|---|---|
| SQL Explorer | Direct SQL access to indexed blockchain data | Trading analytics, historical queries, market analysis |
| Agent Identity (ERC-8004) | On-chain agent discovery and reputation records | Agent identity, capability advertising |
| Blockbook | Wallet-centric blockchain data via JSON-RPC | Address balances, UTXOs, transaction history |
| Metaplex DAS API | Solana Digital Asset Standard — NFTs, cNFTs, fungible tokens, MPL Core | NFT/token queries, compressed NFTs, asset search |
| Ordinals & Runes API | Bitcoin inscriptions and Runes protocol data | Inscription lookup, UTXO tracking, Runes balances |
| Product | Description | Use Case |
|---|---|---|
| Swap API | Multi-DEX aggregated token swaps | Solana (Jupiter/Metis), EVM (0x, OpenOcean, Aerodrome, Velodrome, Titan) |
| Product | Description | Use Case |
|---|---|---|
| Solana Priority Fee API | Recommended priority fees for Solana transactions | Fee estimation, transaction landing |
| Jito Bundles | Solana bundle submission and status APIs | MEV-aware transaction delivery |
| Single Flight RPC | Request de-duplication for identical in-flight RPC calls | High-concurrency read workloads |
| Multi-region Transaction Broadcast | Transaction propagation across multiple regions | Latency-sensitive submission |
| Scorechain Risk Assessment API | Wallet and transaction risk data | Compliance, fraud monitoring |
| Block Timestamp Lookup | Timestamp-to-block lookup utilities | Time-window to block-range conversion |
| Multi-chain Stablecoin Balance API | Stablecoin balances across supported chains | Treasury, payments, portfolio state |
| Covalent GoldRush APIs | Multi-chain wallet and portfolio data | Wallet summaries, token/NFT holdings |
| Product | Description | Use Case |
|---|---|---|
| x402 | Testnet monthly cap plus mainnet pay-per-request via stablecoins | Keyless RPC access, AI agents, pay-as-you-go |
| MPP | Testnet monthly cap plus mainnet pay-per-request via IETF Payment Authentication | AI agents, multi-service payments, high-volume sessions |
| Agent Subscriptions | Wallet-paid Quicknode account creation, returns a QN_* full platform API key | Autonomous agents needing full platform access |
| Quicknode CLI | qn CLI for endpoints, Streams, Webhooks, KV, and SQL from the terminal | Scripting, CI/CD, infrastructure automation |
| Quicknode MCP | Native Claude/OpenAI connector plus generic MCP server — Admin API via MCP | Manage Quicknode from Claude, ChatGPT, Codex, Cursor, or any MCP-capable AI tool |
| Product | Description | Use Case |
|---|---|---|
| Admin API | REST API for account management | Endpoint CRUD, usage monitoring, billing |
| Key-Value Store | Serverless key-value and list storage (beta) | Persistent state for Streams, dynamic address lists |
| Quicknode SDK | Official SDK for Quicknode product APIs | Admin API, Streams, Webhooks, KV, SQL Explorer |
Quicknode provides low-latency RPC endpoints for 80+ blockchain networks.
qn rpc call (CLI) and qn.rpc.call (SDK) reach any supported network via Tooling Access — a single multichain, read-only endpoint Quicknode provisions automatically with short-lived JWTs. No endpoint setup required. See references/cli-reference.md / references/sdk-reference.md. Use a dedicated endpoint below for a fixed URL, non-read-only methods, or dedicated throughput.
// EVM chains (ethers.js)
import { JsonRpcProvider } from 'ethers';
const provider = new JsonRpcProvider(process.env.QUICKNODE_RPC_URL!);
// EVM chains (viem)
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
const client = createPublicClient({
chain: mainnet,
transport: http(process.env.QUICKNODE_RPC_URL!),
});
// Solana
import { createSolanaRpc } from '@solana/kit';
const rpc = createSolanaRpc(process.env.QUICKNODE_RPC_URL!);
Quicknode endpoints include authentication in the URL:
https://{ENDPOINT_NAME}.{NETWORK}.quiknode.pro/{API_KEY}/
For additional security, enable JWT authentication or IP allowlisting in the Quicknode dashboard.
| Category | Networks |
|---|---|
| EVM | Ethereum, Polygon, Arbitrum, Optimism, Base, BSC, Avalanche, Fantom, zkSync, Scroll, Linea, Hyperliquid EVM (HyperEVM) |
| Non-EVM | Solana, Bitcoin, NEAR, Stacks, Cosmos, Sei, Aptos, Sui, TON, Hyperliquid (HyperCore) |
Not exhaustive. Full list: https://www.quicknode.com/chains
As of 2026-02-02. Verify current limits in Quicknode docs before sizing a production system.
| Plan | Requests/sec | Credits/month |
|---|---|---|
| Free Trial | 15 | 10M |
| Build | 50 | 80M |
| Accelerate | 125 | 450M |
| Scale | 250 | 950M |
| Business | 500 | 2B |
See references/rpc-reference.md for complete RPC documentation including method tables for EVM, Solana, and Bitcoin chains, WebSocket patterns, and batch request examples.
Decentralized file storage with Quicknode's IPFS gateway.
See references/ipfs-reference.md for upload examples, metadata examples, and complete IPFS documentation.
Dedicated private node clusters for teams requiring deterministic throughput, regional pinning, or compliance isolation. Agents typically do not provision Dedicated Clusters directly — this is an infrastructure decision made by the account owner.
Marketing: https://www.quicknode.com/clusters Docs: https://www.quicknode.com/docs/custom-rpc-options
Real-time & historical blockchain data pipelines that filter, transform, and deliver data to your destinations.
| Type | Data | Use Case |
|---|---|---|
| Block | Full block data | Block explorers, analytics |
| Transaction | Transaction details | Tx monitoring, indexing |
| Logs | Contract events | DeFi tracking, NFT sales, token transfers |
| Receipt | Transaction receipts | Gas analysis, status tracking |
See references/streams-reference.md for filter examples and full Streams documentation.
On-demand historical data delivery into an existing Stream. Use Backfills to recover gaps, seed a new data store with history, or re-index a range of blocks without rebuilding your pipeline.
Docs: https://www.quicknode.com/docs/streams/backfilling
When asking an agent to trigger a Backfill, provide:
latest)See references/streams-backfills-reference.md for dataset selection, range planning, batching, compression, cost guidance, and automation notes.
Event-driven notifications for blockchain activity.
| Feature | Webhooks | Streams |
|---|---|---|
| Setup | Simple | More configuration |
| Filtering | Address/event-based | Custom JavaScript |
| Destinations | HTTP endpoint only | Webhook, S3, Postgres, Azure |
| Processing | Basic | Full transformation |
| Use Case | Simple alerts | Complex pipelines |
See references/webhooks-reference.md for API examples and full Webhooks documentation.
High-performance Solana Geyser plugin for real-time blockchain data streaming via gRPC. Included on Scale and Business plans; available as a Marketplace add-on on Build and Accelerate plans.
import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc";
// Derive from HTTP URL: https://example.solana-mainnet.quiknode.pro/TOKEN/
const client = new Client(
"https://example.solana-mainnet.quiknode.pro:10000",
"TOKEN",
{}
);
const stream = await client.subscribe();
stream.on("data", (data) => {
if (data.transaction) console.log("Tx:", data.transaction);
});
stream.write({
transactions: {
txn_filter: {
vote: false,
failed: false,
accountInclude: ["PROGRAM_PUBKEY"],
accountExclude: [],
accountRequired: [],
},
},
accounts: {},
slots: {},
blocks: {},
blocksMeta: {},
transactionsStatus: {},
entry: {},
accountsDataSlice: [],
commitment: CommitmentLevel.CONFIRMED,
});
| Filter | Description |
|---|---|
| accounts | Account data changes by pubkey, owner, or data pattern |
| transactions | Transaction events with vote/failure/account filters |
| transactionsStatus | Lightweight transaction status updates |
| slots | Slot progression and status changes |
| blocks | Full block data with optional tx/account inclusion |
| blocksMeta | Block metadata without full contents |
| entry | PoH entry updates |
See references/solana-grpc-reference.md for complete Solana gRPC documentation.
Quicknode-built Solana WebSocket engine. Every standard Solana subscription method (blockSubscribe, accountSubscribe, transactionSubscribe, logsSubscribe, and more) rebuilt for reliability and speed. Included free on all plans — no add-on required. Uses the same WSS endpoint URL (QUICKNODE_WSS_URL) as standard Solana RPC.
Docs: https://www.quicknode.com/docs/solana
const ws = new WebSocket(process.env.QUICKNODE_WSS_URL!);
ws.on('open', () => {
ws.send(JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'blockSubscribe',
params: ['all', { commitment: 'confirmed', encoding: 'jsonParsed' }]
}));
});
ws.on('message', (raw) => {
const msg = JSON.parse(raw.toString());
if (msg.params?.result?.value?.block) {
console.log('New block slot:', msg.params.result.context.slot);
}
});
blockSubscribe, accountSubscribe, logsSubscribe, programSubscribe, signatureSubscribe, slotSubscribe, slotsUpdatesSubscribe, transactionSubscribe, voteSubscribe
Quicknode's data delivery infrastructure for the Hyperliquid L1 chain. Provides gRPC, JSON-RPC, WebSocket, and Info API access. Currently in public beta. Included on all paid plans.
| Method | Path / Port | Use Case |
|---|---|---|
| Info API | /info (POST) | 50+ methods for market data, positions, orders |
| JSON-RPC | /hypercore (POST) | Block queries (hl_getBlock, hl_getBatchBlocks) |
| WebSocket | /hypercore/ws | Real-time subscriptions (hl_subscribe) |
| gRPC | Port 10000 | Lowest-latency streaming for trades, orders, books |
| Stream | Volume | Description |
|---|---|---|
| TRADES | High | Execution data: coin, price, size, side, fees |
| ORDERS | Very High | Order lifecycle with 18+ status types |
| BOOK_UPDATES | Very High | L2 order book diffs |
| TWAP | Low | Time-weighted average price order updates |
| EVENTS | High | Ledger updates, funding, deposits, withdrawals |
| BLOCKS | Extreme | Raw HyperCore blocks (gRPC only) |
| WRITER_ACTIONS | Low | System-level token transfers |
| Path | Debug/Trace | Archive | Use Case |
|---|---|---|---|
/evm | No | Partial | Standard EVM operations |
/nanoreth | Yes | Extended | Debug, trace, WebSocket subscriptions |
See references/hypercore-hyperliquid-reference.md for complete HyperCore and Hyperliquid documentation.
Direct SQL access to indexed blockchain data without requiring infrastructure. Query billions of rows of on-chain data using standard SQL syntax and receive results in seconds.
Docs: https://www.quicknode.com/docs/sql-explorer
curl -X POST 'https://api.quicknode.com/sql/rest/v1/query' \
-H 'x-api-key: YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"query": "SELECT timestamp, coin, side, price, size FROM hyperliquid_trades WHERE block_time > now() - INTERVAL 1 HOUR ORDER BY block_number DESC LIMIT 10",
"clusterId": "hyperliquid-core-mainnet"
}'
Hyperliquid (HyperCore) - Tables covering trades, orders, fills, funding, order book diffs, perpetual markets, spot markets, blocks, transactions, system actions, builder activity, staking, ledger updates, and more.
See references/sql-explorer.md for complete table schemas, query examples, optimization tips, and API reference.
On-chain agent identity and reputation discovery based on the ERC-8004 standard. erc-8004.quicknode.com indexes registrations, feedback, validations, and reputation across supported EVM networks.
API Base: https://erc-8004.quicknode.com
REST prefix: /v1
See references/agent-identity-reference.md for verified endpoints, x402 behavior, rate limits, and on-chain registration guidance.
Wallet-centric blockchain data via the Blockbook JSON-RPC add-on. Provides address balances, UTXO sets, and transaction history across supported chains — particularly useful for UTXO-based chains like Bitcoin where standard RPC methods lack wallet-level indexing.
Marketing: https://www.quicknode.com/blockbook Docs: https://www.quicknode.com/docs/bitcoin/blockbook/overview
Bitcoin (BTC), Ethereum (ETH), Bitcoin Cash (BCH), Dogecoin (DOGE), Litecoin (LTC), Zcash (ZEC) — each as its own add-on on your endpoint.
See references/blockbook-reference.md for methods and examples.
Comprehensive API for querying Solana digital assets — standard NFTs, compressed NFTs (cNFTs), fungible tokens, MPL Core Assets, and Token 2022 Assets. Available as the Metaplex Digital Asset Standard (DAS) API add-on on your Quicknode Solana endpoint. Formerly documented in this skill as "Solana DAS API".
Marketing: https://www.quicknode.com/metaplex-das-api Docs: https://www.quicknode.com/docs/solana/solana-das-api
// Get all assets owned by a wallet
const response = await fetch(process.env.QUICKNODE_RPC_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'getAssetsByOwner',
params: {
ownerAddress: 'E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk',
limit: 10,
options: { showFungible: true, showCollectionMetadata: true }
}
})
});
const { result } = await response.json();
// result.total — total assets
// result.items — array of asset metadata
// result.cursor — for pagination
| Method | Description |
|---|---|
getAsset | Get metadata for a single asset |
getAssets | Get metadata for multiple assets |
getAssetProof | Get Merkle proof for a compressed asset |
getAssetProofs | Get Merkle proofs for multiple assets |
getAssetsByAuthority | List assets by authority |
getAssetsByCreator | List assets by creator |
getAssetsByGroup | List assets by group (e.g., collection) |
getAssetsByOwner | List assets by wallet owner |
getAssetSignatures | Transaction signatures for compressed assets |
getTokenAccounts | Token accounts by mint or owner |
getNftEditions | Edition details of a master NFT |
searchAssets | Search assets with flexible filters |
See references/metaplex-das-reference.md for complete DAS API documentation with all methods, parameters, and examples.
Bitcoin inscription and Runes protocol data via a Quicknode Marketplace add-on. Query inscription metadata, satoshi data, Rune details, and collection data through JSON-RPC and ORD-compatible REST on your Bitcoin endpoint. 21 methods available.
Marketing: https://www.quicknode.com/ordinals-runes Docs: https://www.quicknode.com/docs/bitcoin/ord_getInscription
See references/ordinals-runes-reference.md for supported methods and examples.
Endpoint add-ons for specialized capabilities that can be enabled on Quicknode endpoints. Use the add-on docs or dashboard-provided endpoint details for exact API shapes.
// Get recommended priority fees
const response = await rpc.request('qn_estimatePriorityFees', {
last_n_blocks: 100,
account: 'YOUR_ACCOUNT'
}).send();
MEV-aware Solana bundle submission and status APIs for users who have enabled the Jito add-on.
Request de-duplication for identical in-flight RPC calls. Useful for high-concurrency applications where many workers or users request the same data at the same time.
Broadcast signed transactions through multiple regions to improve propagation for latency-sensitive transaction submission.
Wallet and transaction risk data for compliance, fraud monitoring, and risk-aware transaction workflows.
Timestamp-to-block lookup utilities for converting human time windows into block ranges.
Stablecoin balances across supported chains for treasury, payments, and portfolio workflows.
Multi-chain wallet and portfolio data, including balances, token holdings, NFT holdings, and transaction history where supported.
See references/marketplace-addons.md for current add-on guidance and product-specific reference links.
Multi-DEX aggregated token swaps via Quicknode Marketplace add-ons. Supports Metis/Jupiter, 0x, OpenOcean, Aerodrome, Velodrome, Titan Meta Aggregator, and Hyperliquid Exchange API. Each provider is enabled as a separate add-on or product surface on your endpoint/account.
Marketing: https://www.quicknode.com/swap-api
import { createJupiterApiClient } from '@jup-ag/api';
const jupiterApi = createJupiterApiClient({
basePath: process.env.QUICKNODE_METIS_URL!
});
const quote = await jupiterApi.quoteGet({
inputMint: 'So11111111111111111111111111111111111111112', // SOL
outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
amount: 1_000_000_000, // 1 SOL in lamports
slippageBps: 50
});
const swapResult = await jupiterApi.swapPost({
swapRequest: {
quoteResponse: quote,
userPublicKey: 'YourPubkey...'
}
});
// swapResult.swapTransaction — serialized tx ready for signing
Set QUICKNODE_METIS_URL to your Metis endpoint (e.g., https://jupiter-swap-api.quiknode.pro/YOUR_TOKEN). Enable the Metis Jupiter Swap API add-on in the Quicknode dashboard.
See references/swap-api-reference.md for provider positioning, verified examples, safety defaults, and troubleshooting.
Pay-per-request RPC access via stablecoin payments. No API key required. Three payment models: pay-per-request ($0.001/call), nanopayment (batched via Circle Gateway), and credit drawdown (SIWX auth, $10/1M mainnet credits). Testnet wallets share a monthly cap of 1,000,000 credits per wallet; mainnet wallets are uncapped. Supports USDC on Base/Polygon/Solana and USDG on XLayer. Access 140+ chain endpoints.
import { createQuicknodeX402Client } from "@quicknode/x402";
const client = await createQuicknodeX402Client({
baseUrl: "https://x402.quicknode.com",
network: "eip155:84532", // Base Sepolia payment network
evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,
paymentModel: "pay-per-request",
});
// Use like normal fetch — payment negotiation is handled automatically
const response = await client.fetch("https://x402.quicknode.com/ethereum-mainnet", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "eth_blockNumber",
params: [],
id: 1,
}),
});
See references/x402-reference.md for complete x402 documentation including SIWX authentication, credit management, and @quicknode/x402 setup.
Pay-per-request RPC access via IETF Payment Authentication headers. No API key required. Two intent types: charge ($0.001/request) and session ($0.00001/request via off-chain vouchers). Tempo testnet wallets share a monthly cap of 1,000,000 credits per wallet; mainnet wallets are uncapped. Payment via PathUSD or USDC.e on Tempo mainnet, PathUSD on Tempo testnet, or USDC on Solana. Access 140+ chain endpoints.
import { Mppx, tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
// Polyfills globalThis.fetch — handles 402 challenges automatically
Mppx.create({
methods: [tempo({ account })],
})
// Charge intent ($0.001/req) — payment is transparent
const response = await fetch('https://mpp.quicknode.com/tempo-mainnet', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'eth_blockNumber',
params: [],
}),
})
const { result } = await response.json()
console.log('Block number:', BigInt(result))
See references/mpp-reference.md for complete MPP documentation including charge vs session intents, Solana setup, CLI usage, and payment receipts.
Programmatic Quicknode account creation for autonomous agents. A single POST to /api/v1/agent/subscriptions with an x402 or MPP payment creates a paid account synchronously and returns a QN_* full platform API key, no dashboard signup or email confirmation required. The same payment SDKs used for x402 and MPP per-request RPC sign the subscription payment.
Docs: https://www.quicknode.com/docs/build-with-ai/agent-subscriptions
To fetch the live plan list, prices, accepted payment networks, asset contract addresses, and recipient (payTo) addresses, send the request without a payment header. The server returns HTTP 402 with the details in the body and a PAYMENT-REQUIRED header (base64-encoded x402 requirement).
curl -X POST https://www.quicknode.com/api/v1/agent/subscriptions \
-H "Content-Type: application/json" \
-d '{}'
Parse the 402 body, pick a plan, then retry the request through the SDK.
import { createQuicknodeX402Client } from '@quicknode/x402'
const client = await createQuicknodeX402Client({
baseUrl: 'https://www.quicknode.com',
network: 'eip155:8453', // Base Mainnet
evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,
})
const res = await client.fetch(
'https://www.quicknode.com/api/v1/agent/subscriptions',
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
plan_name: 'b6_build', // b6_build | b6_accelerate | b6_scale | b6_business
interval: 'monthly', // monthly | yearly
email: '[email protected]',
password: process.env.ACCOUNT_PASSWORD,
password_confirmation: process.env.ACCOUNT_PASSWORD,
full_name: 'Autonomous Agent',
name: 'Agent Account',
billing_address: {
line1: '123 Main St',
city: 'New York',
postal_code: '10001',
country: 'US',
},
}),
},
)
const { api_key } = await res.json() // "QN_..." full platform API key
The returned api_key is the same QUICKNODE_API_KEY used everywhere else in this skill. Use it against https://api.quicknode.com/v0/... to provision endpoints, configure security, top up credits, read balances, and so on.
Paying with Solana? Use
@quicknode/x402-solanato sign x402 payments with a Solana keypair instead of an EVM private key. Once configured, the subscription request body and Admin API steps are identical to the x402 example above. See the How to Access Solana RPC with x402 guide for setup details.
import { Mppx, tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
Mppx.create({ methods: [tempo({ account })] })
const subscriptionRes = await fetch(
'https://www.quicknode.com/api/v1/agent/subscriptions',
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
plan_name: 'b6_build', // b6_build | b6_accelerate | b6_scale | b6_business
interval: 'monthly', // monthly | yearly
email: '[email protected]',
password: process.env.ACCOUNT_PASSWORD,
password_confirmation: process.env.ACCOUNT_PASSWORD,
full_name: 'Autonomous Agent',
name: 'Agent Account',
billing_address: {
line1: '123 Main St',
city: 'New York',
postal_code: '10001',
country: 'US',
},
}),
},
)
const { api_key } = await subscriptionRes.json() // "QN_..." full platform API key
| Method | Path | Auth | Rate limit | Purpose |
|---|---|---|---|---|
| POST | /api/v1/agent/subscriptions | Payment header (x402 or MPP) | 20/min, 5/hour by IP + email | Create account and subscription |
| POST | /api/v1/agent/top_up | API key + payment header | 30/min by API key | Add credits to an existing subscription |
| GET | /api/v1/agent/balance | API key | 60/min by API key | Read current credit balance |
All requests target https://www.quicknode.com.
b6_build, b6_accelerate, b6_scale, b6_business. Map directly to the public Build / Accelerate / Scale / Business plans on pricing. Use the discovery 402 above when the agent needs to choose a plan dynamically.
email and password instead of creating a duplicate account.See references/agent-subscriptions-reference.md for complete endpoint reference, top-up flow, and balance checks.
Command-line tool (qn) for managing Quicknode infrastructure from the terminal. Available on all paid plans.
# Homebrew
brew install quicknode/tap/qn
# Docker
docker pull quiknode/qn-cli:latest
Use interactive login for local work, or pass the API key explicitly in non-interactive environments:
qn auth login
qn auth login --api-key <KEY>
qn auth whoami
Credential precedence is --api-key, then --config-file, then ~/.config/qn/config.toml. The CLI does not read API keys directly from environment variables.
qn agent context
qn agent context -o json
# Endpoints
qn endpoint list
qn endpoint create --chain ethereum --network mainnet
# RPC (Tooling Access) — no endpoint setup required
qn tooling-access status
qn tooling-access enable
qn rpc call eth_getBlockByNumber '["latest", false]' --network base-mainnet
# Account and chain metadata
qn auth whoami --format json
qn chain credits ethereum --format json
# SQL Explorer
qn sql query "SELECT COUNT(*) FROM hyperliquid_trades" --cluster-id hyperliquid-core-mainnet --format json
qn sql schema hyperliquid-core-mainnet
# Streams / Webhooks / KV
qn stream list
qn webhook list
qn kv set get my-key
Use --format json for machine-readable output. Mutating commands prompt before acting; require explicit user confirmation before bypassing prompts in automation.
See references/cli-reference.md for complete CLI documentation.
Native Claude/OpenAI connector and generic MCP server that exposes Quicknode Admin API capabilities to AI assistants via the Model Context Protocol (MCP).
Claude Web/Desktop: Settings → Customize → Connectors → find Quicknode → Connect.
Claude Code:
claude mcp add --transport http quicknode https://mcp.quicknode.com/mcp
Interactive setup uses OAuth: log in to Quicknode, select Viewer or Admin, and approve access. Use Viewer for read-only inspection and Admin only when the assistant needs to create, delete, or modify resources.
OpenAI (ChatGPT/Codex): Install Quicknode from the ChatGPT Apps catalog or via /plugin in Codex when available. Use the consolidated OpenAI tab on the Quicknode MCP docs page for current setup details.
The MCP server provides tools for endpoint management (list, create, delete, rate limits), security rules, usage monitoring, billing, and chain discovery. Agents and users can manage their Quicknode workspace conversationally without leaving their AI tool.
See references/mcp-reference.md for the complete tool surface and setup instructions.
Official SDK for Quicknode product APIs: Admin API, Streams, Webhooks, Key-Value Store, and SQL Explorer. The rpc client (Node 3.7.0+, other languages 0.7.0+) also makes JSON-RPC calls to any supported network via Tooling Access — no endpoint setup required. Chain-specific client libraries still apply for typed chain abstractions or a dedicated endpoint.
npm install @quicknode/sdk
import { QuicknodeSdk } from '@quicknode/sdk';
const qn = QuicknodeSdk.fromEnv();
const endpoints = await qn.admin.getEndpoints({
limit: 20,
sortBy: 'created_at',
sortDirection: 'desc',
});
const account = await qn.admin.accountInfo();
const apiCredits = await qn.admin.getApiCredits('ethereum');
const trades = await qn.sql.query(
'SELECT * FROM hyperliquid_trades LIMIT 5',
'hyperliquid-core-mainnet'
);
See references/sdk-reference.md for complete SDK documentation.
REST API for programmatic management of Quicknode endpoints, usage, rate limits, security, billing, and teams. Enables infrastructure-as-code workflows.
| Resource | Methods | Endpoint |
|---|---|---|
| Chains | GET | /v0/chains |
| Account Info | GET | /v0/account/info |
| API Credits | GET | /v0/api-credits/{chain} |
| Endpoints | GET, POST, PATCH, DELETE | /v0/endpoints |
| Metrics | GET | /v0/endpoints/{id}/metrics |
| Rate Limits | GET, POST, PUT | /v0/endpoints/{id}/method-rate-limits, /v0/endpoints/{id}/rate-limits |
| Security | GET | /v0/endpoints/{id}/security_options |
| Tooling Access | GET, PATCH, POST | /v0/tooling-access, /v0/tooling-access/token |
| Usage | GET | /v0/usage/rpc, by-endpoint, by-method, by-chain |
| Billing | GET | /v0/billing/invoices |
| Teams | GET | /v0/teams |
All requests use the x-api-key header against https://api.quicknode.com/v0/.
const QN_API_KEY = process.env.QUICKNODE_API_KEY!;
const res = await fetch('https://api.quicknode.com/v0/endpoints', {
headers: { 'x-api-key': QN_API_KEY },
});
const endpoints = await res.json();
See references/admin-api-reference.md for full Admin API documentation including endpoint CRUD, usage monitoring, rate limit configuration, security options, Tooling Access, billing, and teams.
Serverless storage for lists and key-value sets, primarily accessed from within Streams filter functions via the qnLib helper library. Also available via REST API.
List operations — manage lists of items (e.g., wallet addresses):
qnLib.qnUpsertList — create or update a listqnLib.qnAddListItem — add item to a listqnLib.qnRemoveListItem — remove item from a listqnLib.qnContainsListItems — batch membership checkqnLib.qnDeleteList — delete a listSet operations — manage key-value pairs:
qnLib.qnAddSet — create a key-value setqnLib.qnGetSet — retrieve value by keyqnLib.qnBulkSets — bulk create/remove setsqnLib.qnListAllSets — list all set keysqnLib.qnDeleteSet — delete a setSee references/kv-reference.md for REST API usage, size limits, and CLI (qn kv) commands.
The following Quicknode products are available but agents typically do not invoke them directly. They are provisioned by account owners through the dashboard or by a human operator.
import { JsonRpcProvider } from 'ethers';
const ethereum = new JsonRpcProvider(process.env.QUICKNODE_ETH_RPC_URL!);
const base = new JsonRpcProvider(process.env.QUICKNODE_BASE_RPC_URL!);
const [ethBlock, baseBlock] = await Promise.all([
ethereum.getBlockNumber(),
base.getBlockNumber(),
]);
/info) for account state and market metadataSELECT * FROM hyperliquid_trades WHERE block_time > ...GROUP BY for volume, counts, averagesWHERE block_time > ...)https://www.quicknode.com/docs/{chain-or-product}/llms.txt)Automatically, when a task matches. Use for any Quicknode product, blockchain data access, or wallet-paid agent access.
Skills that do similar work, with their headline benchmark lift.
From the same source and nearby in the catalogue.