LI.FI's API for Agentic Commerce is a single integration point for AI agents to execute any action across blockchains. The same API powering leading wallets and DeFi applications is now optimized for agent-native environments. 

Introducing an MCP server that exposes LI.FI’s capabilities through a standardized interface for AI agents, making them discoverable and callable across agent ecosystems. We’ve built AI agent skills for LI.FI’s capabilities to execute swaps, bridging or compose any DeFi workflow, ​​which are now distributed across major agent directories. Our documentation is now AI-first, designed to be easily parsed and executed by autonomous entities. 

Together, this enables agents and companies to build autonomous DeFi workflows without friction, and accelerate the era of agentic commerce on blockchains. Learn more in our docs, or go straight to the API endpoint and get a quote.

AI-First Infrastructure for Agentic Commerce

AI agents are becoming economic actors. They can monitor markets, make decisions, and execute transactions without human intervention. But while blockchains provide the execution layer for digital value, they were not designed for autonomous systems. Fragmentation across chains, bridges, and protocols makes reliable execution difficult, especially for agents that need deterministic outcomes.

LI.FI’s API for Agentic Commerce is the infrastructure layer that makes blockchains easily operable by AI agents.

AI agents deliver 24/7 autonomous operations and reliable execution. In the future, they will be the power users of blockchains. LI.FI's mission is to accelerate the era of agentic commerce, providing the infrastructure to make autonomous onchain actions as seamless as possible.

LI.FI is built to move value across chains at scale and with reliability, delivering the efficiency and dependability that autonomous workflows demand. We integrate and maintain every possible integration, compare quotes across all of them, and surface the best option for the required use case – the most comprehensive solution for executing any action onchain. This is exactly what AI agents need to operate without friction. LI.FI's API for Agentic Commerce unlocks the full DeFi infrastructure stack agents need to act onchain.

A Complete Toolkit for AI Agents

To make our infrastructure fully accessible to agents, we’re introducing dedicated tooling designed specifically for agent-native environments:

MCP Server

LI.FI now operates a hosted Model Context Protocol (MCP) server, available at: https://mcp.li.quest/mcp

This server wraps the entire LI.FI API into structured tools that AI agents can call directly. This removes the need for agents to construct HTTP requests manually, translating LI.FI’s execution capabilities into standardized, callable functions.

Key capabilities include:

• Live and deployable today – A hosted MCP server that wraps the entire LI.FI REST API into MCP-compatible tools. Zero-install: paste the config JSON into any MCP client and start calling LI.FI tools directly, no HTTP request construction required.

• 15+ structured tools across six categories – token info, chain info, quote and swap execution, discovery and routing, gas info, and balance and allowance queries. Key tools include get-quote, get-chains, get-token, get-status, and health checks.

• Compatible with – Claude, Cursor, Windsurf, VS Code Copilot. Installation guides available for all four.

• Code samples provided – for Anthropic API (TypeScript and Python), MCP SDK (TypeScript and Python), and Vercel AI SDK.

• Listed in agent directories and discoverable by AI tools – The MCP server is published and indexed across major agent directories, making LI.FI's capabilities callable and discoverable within agent ecosystems without manual configuration.

Agent Skills

LI.FI’s capabilities are also distributed as standardized skills within agent ecosystems. These allow agent developers to add cross-chain execution to their agents as a native capability.

Available today:

• ClawdHub – Published as the lifi-crosschain skill, exposing LI.FI’s execution layer to agents within the ClawdHub ecosystem.

• skills.sh – Published as a standardized LI.FI-agent-skill, enabling swaps, bridging, and multi-step DeFi workflows across agent frameworks.

• Playbooks skill directory – also available via Playbooks as the official li-fi-api skill, making it accessible across agent frameworks. This allows any Playbooks-compatible agent to integrate cross-chain execution in minutes.

Agent-Native Documentation

Traditional API documentation is written for humans. Agents require documentation designed for machine interpretation. LI.FI now provides a dedicated agent integration layer at: https://docs.li.fi/agents/

Our efforts to optimize documentation for AI agents include:

• llms.txt – Machine-readable documentation available at https://docs.li.fi/llms.txt. Structured for direct LLM consumption, providing a canonical overview of endpoints, pages, and decision rules without HTML or formatting noise.

• AI Plugin Discovery – Standard ai-plugin.json published at https://docs.li.fi/.well-known/ai-plugin.json, enabling AI tools to automatically discover and understand LI.FI's API capabilities.

• OpenAPI 3.0 Specification – Full OpenAPI 3.0.2 spec covering 28+ endpoints, available as a downloadable YAML file. Supports SDK generation, API testing tool imports (Postman, Insomnia), and direct LLM tool integration.

• Decision tables – Deterministic logic for: Quote vs Routes, API vs SDK vs Widget, route selection criteria, same-chain vs cross-chain detection, amount handling and conversion formulas, and error recovery. All in structured table format with pseudocode decision trees agents can execute directly.

• Five-call recipe – A minimal, ordered sequence of five API calls covering the complete swap and bridge workflow from discovery to confirmation.

• Runnable code samples – in Node.js (API-only), Node.js (with SDK), and Python, including retry logic, exponential backoff, and status polling out of the box.

• Error playbooks – Every HTTP status code and API error code mapped to: cause, retry eligibility, required fix, user-facing message templates, and handling code snippets.

• Full data schemas – TypeScript interfaces for Chain, Token, Quote, Action, Estimate, TransactionRequest, and Status objects, plus validation rules, enum definitions, and format patterns.

• Status and recovery workflows – Polling strategies with recommended backoff schedules, and handling logic for every terminal state: COMPLETED, PARTIAL, REFUNDED, and FAILED.

• Partial completion handling – Detection logic, recovery flows, decision trees, and communication templates for cross-chain transfers that partially complete.

API Rate Limits for Agent-Scale Workloads

Agent systems generate high-frequency execution patterns. LI.FI’s infrastructure is designed to support this at scale.

Rate limits for AI agents include:

• Without API key – 200 requests per 2 hours

• With API key – 200 requests per minute

This enables agents to operate continuously and reliably.

The Execution Engine for Agentic Commerce

Blockchains provide open, programmable financial systems. AI agents provide autonomous decision-making. LI.FI provides the execution layer connecting the two.

By abstracting fragmentation and exposing execution through agent-native interfaces, LI.FI makes it possible for agents to operate seamlessly across blockchains.

This unlocks a new category of applications:

Autonomous trading agents. 

Autonomous treasury management. Autonomous payment systems. Autonomous execution for any action onchain.

Applications run by agents, powered by LI.FI.

This is agentic commerce.

Get Started:

• Explore the documentation: https://docs.li.fi/agents/

• Access the MCP server: https://mcp.li.quest/mcp

• Request a quote: https://li.quest/v1/quote

FAQ: Introducing LI.FI’s API for Agentic Commerce