Elfa API Skill

This skill enables Claude to work with the Elfa API — a social listening
and market context layer for crypto traders. Elfa ingests real-time data from Twitter/X, Telegram,
and other sources, then structures sentiment, narratives, and attention shifts into actionable
trading insights.

When to use this skill

• - User asks about trending tokens, narratives, or contract addresses in crypto
• User wants social mentions for a specific ticker or keyword
• User wants smart stats (smart followers, engagement) for a Twitter/X account
• User wants an AI-generated market summary, macro overview, or token analysis
• User asks how to integrate, call, or use the Elfa API
• User wants code examples (curl, Python, JavaScript/TypeScript) for Elfa endpoints
• User mentions "elfa" in a crypto or trading data context

API Overview

Base URL: https://api.elfa.ai
Version: v2 (current)

Two access modes

Elfa supports two independent ways to authenticate requests:

Mode	Endpoint prefix	Auth header	Best for
API key	INLINECODE1	INLINECODE2	Humans & apps with a registered key
x402 (keyless)

/x402/v2/ | X-PAYMENT: <signed-payload> | Agents & wallets — no signup needed |

Both modes access the same data. The only difference is how you authenticate:

• - API key — register at https://go.elfa.ai/claude-skills, get 1,000 free credits.
• x402 — pay per request with USDC on Base. No registration, no API key. Currently in beta.

Endpoints at a glance

All endpoints below work with both /v2/ (API key) and /x402/v2/ (keyless) prefixes,
except key-status which is API key mode only.

Endpoint	Method	Description
INLINECODE8	GET	API key usage & limits (API key mode only)
INLINECODE9

GET | Trending tokens by mention count |
| /v2/account/smart-stats | GET | Smart follower & engagement stats for a Twitter account |
| /v2/data/top-mentions | GET | Top mentions for a ticker symbol |
| /v2/data/keyword-mentions | GET | Search mentions by keywords or account name |
| /v2/data/event-summary | GET | AI event summaries from keyword mentions (5 credits) |
| /v2/data/trending-narratives | GET | Trending narrative clusters (5 credits) |
| /v2/data/token-news | GET | Token-related news mentions |
| /v2/aggregations/trending-cas/twitter | GET | Trending contract addresses on Twitter |
| /v2/aggregations/trending-cas/telegram | GET | Trending contract addresses on Telegram |
| /v2/chat | POST | AI chat with multiple analysis modes |

For full parameter details, read references/api-reference.md.

How to use this skill

Step 1: Determine the mode

Check whether the user wants to make a live call or get code/integration help.

• - If the user says things like "show me trending tokens", "what's the sentiment on SOL",

"get me the top mentions for ETH" → they want live data. Proceed to Step 2a.

• - If the user says things like "how do I call the trending tokens endpoint", "give me a

curl example", "help me integrate Elfa" → they want code snippets. Skip to Step 3.

• - If the user mentions x402, keyless, pay-per-request, or wallet-based access

→ they want x402 mode. See Step 2b for live calls or Step 3 for code snippets.

Step 2a: Making live API calls (API key mode)

Use the bash_tool to call the Elfa API via curl.

Getting the API key:

1. 1. Check if the ELFA_API_KEY environment variable is set. This is the preferred method.
2. If the env var is not set, stop and prompt the user. Offer both options:

> To make live calls, you have two options:
>
> Option A — API key (free tier): Get a free key with 1,000 credits at
> https://go.elfa.ai/claude-skills — then set it as the ELFA_API_KEY environment
> variable (do not paste it directly into the chat).
>
> Option B — x402 keyless payments: Pay per request with USDC on Base — no signup
> needed. See the x402 docs for setup.

Do not attempt any authenticated API calls without a key or x402 setup. Wait for the user.

1. 3. Credential safety:

- Always read the API key from the ELFA_API_KEY environment variable, never ask the
user to paste it into the conversation.
- Never log or expose the full API key in outputs — mask it when displaying curl commands.
- If a user does paste a key in chat, warn them to rotate it and set it as an env var instead.

Free tier limitations:
The free tier provides 1,000 credits that work on most endpoints. However, the following
endpoints require a Pay-As-You-Go or Grow plan:

• - Trending narratives
• AI chat

If a user hits an authorization error on one of these endpoints, let them know they can
upgrade their plan or use x402 payments instead. Full details at https://go.elfa.ai/claude-skills.

Making the call:

CODEBLOCK0

Step 2b: Making live API calls (x402 keyless mode)

x402 lets any wallet pay per request using USDC on Base — no API key, no registration.
This is ideal for agents, bots, and programmatic access.

How x402 works:

1. 1. Send a request to the /x402/v2/ version of any endpoint (no auth header).
2. The server responds with HTTP 402 containing payment requirements.
3. Your wallet signs a USDC transfer authorization (no gas fees).
4. Resend the request with the signed payment in the X-PAYMENT header.
5. Server verifies payment, serves the response, and settles on-chain.

x402 signing and security:

• - Signing happens entirely client-side using the @x402/fetch or INLINECODE27

libraries. The agent never handles, stores, or transmits private keys.

• - The user's wallet private key is used only locally by the x402 library to sign

EIP-712 typed data authorizing a specific USDC amount for a specific request.

• - Never ask the user to share their wallet private key or seed phrase in the conversation.
• When generating x402 code examples, use "0xYOUR_PRIVATE_KEY" as a placeholder and

advise the user to load it from an environment variable (e.g., process.env.PRIVATE_KEY).

x402 details:

• - Chain: Base (eip155:8453)
• Currency: USDC on Base (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913)
• Status: Currently in beta

x402 pricing:

Tier	Cost	Endpoints
Standard (1 credit)	$0.009	trending-tokens, smart-stats, keyword-mentions, token-news, top-mentions, trending-cas
Extended (5 credits)

$0.045 | event-summary, trending-narratives |
| Chat — fast | $0.225 | chat (speed: "fast") |
| Chat — expert | $1.00 | chat (speed: "expert", default) |

Making an x402 call with curl (manual flow):

CODEBLOCK1

Recommended: use the @x402/fetch library which handles payment automatically:

CODEBLOCK2

x402 with the Chat endpoint (POST):

CODEBLOCK3

Presenting results:

• - Parse the JSON response and present it in a clean, readable format.
• For trending tokens: show a ranked table with token name, mention count, and change %.
• For mentions: show tweet links, engagement metrics, and account info.

Note: Elfa returns tweet IDs but not tweet text content — let the user know they'll
need their own X (Twitter) API key to fetch the actual tweet content.

• - For narratives/summaries: present the narrative text with source links.
• For the chat endpoint: display the AI response cleanly.
• If the response contains an error, explain what went wrong and suggest fixes.

Step 3: Generating code snippets

When the user wants integration help, generate correct, production-ready code.
Read references/api-reference.md for the full parameter specs.

Principles for code generation:

• - Always mention both access modes (API key and x402) so developers know their options
• Include the signup link https://go.elfa.ai/claude-skills as a comment near the

API key placeholder, and link to https://docs.elfa.ai/x402-payments for x402

• - Always include proper error handling
• For API key mode: show the x-elfa-api-key header (use a placeholder like YOUR_API_KEY)
• For x402 mode: show the /x402/v2/ prefix and recommend @x402/fetch or INLINECODE40
• Include TypeScript types when generating TS code
• Add comments explaining each parameter
• For pagination endpoints, show how to paginate through results
• For time-windowed endpoints, explain the timeWindow vs from/to pattern

Language priorities (use unless the user specifies otherwise):

1. 1. TypeScript/JavaScript (fetch) — most Elfa integrators are web/Node devs
2. Python (requests)
3. curl

The Chat endpoint deserves special attention — it's the most complex:

• - It supports multiple analysisType values: chat, macro, summary, tokenIntro,

tokenAnalysis, accountAnalysis

• - Session management via sessionId for multi-turn conversations
• Different assetMetadata requirements per analysis type
• Two speed modes: fast and INLINECODE54

Common patterns

Time window parameters:
Many endpoints accept either timeWindow (e.g., "30m", "1h", "4h", "24h", "7d", "30d")
OR from/to unix timestamps. If both are provided, from/to takes priority.

Pagination:
Most list endpoints support page and pageSize. The keyword-mentions endpoint uses
cursor-based pagination instead (cursor parameter).

Ticker format:
For top-mentions, the ticker param can be prefixed with $ to match only cashtags
(e.g., $SOL vs SOL).

Credit costs (both modes):

• - Most endpoints: 1 credit per call ($0.009 via x402)
• Event summary: 5 credits ($0.045 via x402)
• Trending narratives: 5 credits ($0.045 via x402)
• Chat endpoint: varies — fast $0.225, expert $1.00 via x402

Important notes

• - The Elfa API domain (api.elfa.ai) must be accessible from the network. If blocked,

inform the user and provide the code snippet instead.

• - Always use the v2 endpoints (paths starting with /v2/ or /x402/v2/).
• For experimental endpoints (trending-tokens, smart-stats), mention that behavior may

change without notice.

• - When the user asks about pricing or API key tiers, direct them to

https://go.elfa.ai/claude-skills for full details on plans and pricing.

• - x402 is currently in beta. Rate limits apply per wallet address (not per API key).
• x402 and API key credits are independent — they do not overlap or share balances.
• For x402 documentation and setup, refer users to https://docs.elfa.ai/x402-payments.

Troubleshooting

CORS or network errors in the Claude desktop app:
If the user is running this skill in the Claude desktop app and API calls are failing due
to CORS or network issues, guide them through this fix:

1. 1. Open Settings in the Claude desktop app
2. Go to Capabilities
3. Enable Network Egress
4. Add *.elfa.ai to the allowed domains list

This grants the app permission to make outbound requests to the Elfa API.