Quickstart for AI

A blockchain tool platform for AI agents, Nodit connects 81+ blockchain networks to AI through Skills, MCP, and llms.txt, and enables automated on-chain data access and transaction execution via the x402 protocol — without requiring an account.

0. Prerequisites

At least one of the following must be in place before you begin.

• API Key-based calls: Sign up at the Nodit Console, create a project, and issue an API Key.
• x402-based calls: A wallet that supports EIP-712 signing and a USDC balance are required. APIs can be called using only a wallet, with no account registration needed.

Prepare your AI agent environment as well.

1. Choose an Execution Path: Skills, MCP, or CLI

Connect an execution path so the AI agent can invoke Nodit APIs as tools.

1-1. Setting Up the Skills Path

Install Nodit Skills to give an AI coding agent access to Nodit API specifications and usage patterns.

• Nodit Skills GitHub Repository

# Install all skills
npx skills add noditlabs/skills --yes

# Install only the skills you need
npx skills add noditlabs/skills --skill web3-tools
npx skills add noditlabs/skills --skill web3-x402

web3-tools is the foundational skill that connects Nodit API structure and call patterns to the agent. web3-x402 handles payments via the x402 protocol. Installing both skills together lets an agent handle API calls and payments in a single workflow.

1-2. Setting Up the MCP Path

To use Nodit APIs as tools in an MCP client, connect to the Remote MCP server hosted by Nodit. The connection uses Streamable HTTP transport with OAuth login, so the API Key is never entered in a configuration file or URL.

• Nodit MCP Server GitHub Repository
• @noditlabs/nodit-mcp-server on npm

The Nodit MCP server provides tools for listing projects, listing APIs, retrieving specifications, and making actual calls.

Adding the Connector in Claude (Web / Desktop)

The Remote MCP server automatically locates and uses an API Key from a project in the signed-in account. The following must therefore be in place.

• Nodit account: An account that can sign in to the Nodit Console
• At least one project in RUNNING status: With at least one API Key in ACTIVE status in that project
• MCP client: A client that supports Streamable HTTP and OAuth, such as Claude (web/desktop), Claude Code, or Cursor

In Claude, register the Remote MCP server as a custom connector.

1. Select Settings > Connectors > Add custom connector.
2. Enter Nodit in the connector search box. Confirm that the server URL matches https://mcp.nodit.io/mcp, then click [Connect] to add the connector.
3. Once the connector is added, the Nodit sign-in page opens. Sign in with your Nodit account and approve the permissions.
4. When the connection completes successfully, the Nodit MCP is available in Claude.

Adding the MCP in Claude Code

In Claude Code, register the server with the command below. The first time a tool is called in a session, a browser window opens and prompts you to sign in.

claude mcp add --transport http nodit https://mcp.nodit.io/mcp

If https://mcp.nodit.io/mcp is not entered exactly, a 401 error may occur.

To share the configuration at the project level, add the following to .mcp.json at the repository root.

{
	"mcpServers": {
		"nodit": {
			"type": "http",
			"url": "https://mcp.nodit.io/mcp"
		}
	}
}

Adding to Cursor

In Cursor, add the server URL to ~/.cursor/mcp.json. A sign-in window opens on first use.

{
	"mcpServers": {
		"nodit": {
			"url": "https://mcp.nodit.io/mcp"
		}
	}
}

Selecting a Project

The OAuth token identifies only the account. Because each API call consumes CU from a specific project, the project to use must be determined.

• If the account has one RUNNING project, that project is used automatically without any additional setting.
• If there are two or more, check the list with list_nodit_projects, and when calling call_nodit_api or call_nodit_aptos_indexer_api, add a prompt that identifies the project, such as "Query this using [project name]", so that the projectId is specified.
• projectId is the numeric ID shown in the console. The server retrieves the API Key directly from the project, so there is no need to pass the key to the model. To avoid exposing the key, not passing it is recommended.

Show me my Nodit projects.
Get the token balances of 0x... on Ethereum mainnet.
Using project 12345, get the latest block number on Polygon mainnet.

Common Issues

If a connection or call fails, check the table below for the matching symptom.

Migrating from an Existing SSE Connection

The existing https://mcp.nodit.io/sse?apiKey=... method remains available for the time being. However, because the SSE transport has been deprecated in the MCP specification, Streamable HTTP is recommended for new connections. To migrate, remove the existing SSE connector and add a new one following the steps above. Since the API Key is no longer placed in the URL, the risk of key exposure is eliminated.

Local MCP Server (Optional)

Instead of the Remote server, the MCP server can also be run locally. This method passes the API Key as an environment variable rather than using OAuth.

Claude Desktop — ~/Library/Application Support/Claude/claude_desktop_config.json
Cursor IDE — ~/.cursor/mcp.json

{
	"mcpServers": {
		"nodit": {
			"command": "npx",
			"args": ["@noditlabs/nodit-mcp-server@latest"],
			"env": {
				"NODIT_API_KEY": "{YOUR_API_KEY}"
			}
		}
	}
}

1-3. Setting Up the CLI Path

Nodit CLI is a command-line tool that calls the RPC API, Data API, Webhook, and Stream with a single nodit command. Successful results are written to data on stdout and failures to error on stderr in a consistent structure, so an AI agent that can run shell commands can read the result directly and use it in the next step.

Install it with the command for your operating system. After installation, open a new terminal and run nodit version to print the installed version.

curl -fsSL https://raw.githubusercontent.com/noditlabs/nodit-cli/main/scripts/install.sh | sh

irm https://raw.githubusercontent.com/noditlabs/nodit-cli/main/scripts/install.ps1 | iex

A person first signs in and connects a project for the API Key the agent will use. When you select a project, its API Key is stored in the OS credential store (Keychain, libsecret, Credential Manager) and applied automatically to subsequent nodit commands. The CLI never prints the API Key value, so the key does not appear in the output of commands the agent runs.

nodit auth login
nodit project list
nodit project select {PROJECT_ID}

In CI or script environments where a browser login is not possible, inject the API Key through the NODIT_API_KEY environment variable from a secret store such as GitHub Secrets. Typing it directly with export or writing it to .env or a shell profile leaves the key in plain text, and an agent that runs shell commands can read and print environment variables.

Add usage rules like the following to your agent instructions (CLAUDE.md, AGENTS.md, etc.), and the AI will call the Nodit CLI whenever it needs blockchain data. --no-interactive returns an error instead of an input prompt, and -o json prints results as JSON that is easy to parse.

When blockchain data is required, use the Nodit CLI (`nodit`).
- Always add `--no-interactive -o json` to every command.
- Run `nodit network list` to check supported networks before calling an unfamiliar network.
- Read the result from `data` on stdout. If `error` is returned on stderr, report its `code` and `message`.
- Never print environment variables or credentials (for example, `env` or `echo $NODIT_API_KEY`).
- Do not run state-changing methods such as `eth_sendRawTransaction` without explicit approval.

Once set up, a request like the one below makes the AI run a command such as nodit rpc eth_blockNumber -n ethereum-mainnet --no-interactive -o json and return the result.

Use the Nodit CLI to get the latest block number and the native token balance of
0x000000000000000000000000000000000000dEaD on Ethereum mainnet.

Authentication methods, default network settings, and per-command options are covered in Nodit CLI.

2. llms.txt (Optional)

llms.txt is not required when using Skills or MCP, since both paths already include Nodit API structure and usage context. You can add llms.txt as supplementary context in the following situations.

• You need to convey the Nodit documentation structure to an AI without installing any tools.
• You want to include an official documentation summary in a system prompt.
• You want to verify how well the AI understands Nodit before connecting Skills or MCP.

2-1. Locating llms.txt

Copy the content at the URL below, or configure your AI tool to reference it directly if it supports external document ingestion.

https://developer.nodit.io/llms.txt

2-2. Building a Basic Instruction Set for the AI

When using llms.txt, pairing the documentation summary with operational instructions improves the accuracy of the AI's responses. The example below is a minimal setup applicable to AI coding agents or custom agent runtimes.

You are working with Nodit, a multichain blockchain data platform.

Use Nodit's llms.txt as supporting context:
https://developer.nodit.io/llms.txt

When blockchain data is required:
1. Identify the relevant Nodit API category or method.
2. Prefer official Nodit tools or documented API patterns.
3. If the environment supports wallet-based payment, use x402 when API Key authentication is not available.
4. Explain which chain, network, and method you chose before making the request.

2-3. Verification Prompt Examples

After providing llms.txt, use prompts like the one below to confirm the AI understands Nodit API structure before connecting any tools.

Use Nodit to find the latest Ethereum mainnet block.
Before calling anything, explain which Nodit API you would use and why.

3. Make Your First Call

With an execution path connected, use the example below to make a real API call — retrieving the latest block on Ethereum Mainnet.

3-1. Sample Prompt

The prompt below works with Skills, MCP, and CLI.

Use Nodit to get the latest block on Ethereum mainnet.
1. Identify the API category and method first.
2. Call the API.
3. Return the block number, block hash, and timestamp.

3-2. Expected Execution Flow

When configured correctly, the AI follows these steps.

1. Checks the Nodit API structure from the connected tool.
2. Selects the appropriate method from Data API or RPC API.
3. Checks the API specification or supported networks via Skills, MCP, or CLI.
4. Authenticates using an API Key or x402 and sends the request.
5. Extracts and returns the relevant fields from the response.

4. Connect x402 Payment

Use x402 when API requests need to be processed using only a wallet signature, without an API Key. x402 is an HTTP 402 Payment Required-based payment protocol and is supported by RPC API (JSON-RPC) and Data API.

4-1. How x402 Works

x402 receives payment conditions at request time, signs them, and resubmits the request.

1. The agent sends a request to a Nodit API.
2. Nodit returns 402 Payment Required along with payment conditions.
3. The agent signs the payment data using a wallet.
4. The agent resubmits the same request with the signed data included.
5. Nodit validates the payment and returns the API response.

4-2. Using x402 with Skills

web3-x402 is designed to work alongside web3-tools. web3-tools determines which API to call, while web3-x402 handles wallet authentication and payment processing.

Use Nodit to fetch the latest Ethereum mainnet block.
If API Key authentication is unavailable, use x402 payment.

4-3. Choosing a Payment Mode

x402 offers two modes depending on your call pattern. Start with Pay-Per-Use to validate behavior, then switch to Credit as call volume increases.

For detailed differences and implementation steps, refer to the documents below.

• What is x402?
• How to use Pay-Per-Use
• How to use Credit

Next Steps

• Nodit CLI — Installation, authentication, and commands for the command-line tool that calls Nodit APIs from the terminal
• Supported Chains — Feature coverage by chain, paid plan requirements, and testnet retention policy
• Data API — Query API backed by on-chain data indexing
• Webhook — Send notifications to a designated server when on-chain events occur
• Stream — Subscribe to on-chain events in real time over a persistent WebSocket channel
• What is x402? — Overview of the x402 protocol and payment flow
• Supported APIs & Pricing — List of chains and methods supported by x402