Project type: Cross-chain Infrastructure

Cross-Chain Interoperability Protocol (CCIP) | Chainlink
ProductsData[[Compute[[[[Use CasesUse Cases![ services powering hybrid smart contract use cases across a wide-variety of industriesLearn more! Tokenization
The era of secure blockchain interoperability has arrived.
Start building today to an expert](## A secure interoperability protocol for
enabling token transfers across blockchainssending cross-chain messagesbuilding cross-chain applicationsenabling cross-chain real-world assetsscaling cross-chain ecosystemsconnecting private and public blockchainsenabling token transfers across blockchains![](### Defense-in-depth security
Powered by Chainlink’s industry-standard oracle networks. Cross-Chain Interoperability Protocol (CCIP) also features additional layers of protection via the Risk Management Network and transfer rate limits.
Seamlessly scale your userbase and benefit from enhanced token composability by securely transferring tokens across chains in a fraction of the time it would take to build a custom solution.
Send tokens and instructions for their use to a receiving smart contract on a different blockchain—specify to swap or stake assets once they arrive at the destination chain, for example.
A transaction price is quoted on the source chain via a gas-locked fee payment mechanism that confirms execution regardless of destination chain gas spikes and network congestion.
A single, easy-to-integrate interface for a unified cross-chain developer experience. Simply integrate CCIP onchain and start building secure cross-chain applications.
CCIP will continue to be updated over time to support new blockchains, enhanced functionalities, and additional defense-in-depth approaches.
## Start building with Chainlink CCIP
Securely send messages, transfer tokens, and initiate actions across blockchains.
[A single, elegant interface
For all cross-chain use cases.](#w-tabs-0-data-w-pane-0)[Programmable token transfers
Transfer tokens cross-chain, along with additional instructions about their use.](#w-tabs-0-data-w-pane-1)[Arbitrary messaging
Send arbitrary data to a receiving smart contract on a different blockchain.](#w-tabs-0-data-w-pane-2)[
// The message to send cross-chain with CCIP
bytes receiver; // Receiver at destination
bytes data; // Arbitrary data payload
EVMTokenAmount[] tokenAmounts; // ERC20 tokens and amounts
address feeToken; // Token to pay fees with
bytes extraArgs; // Optional parameters
// Sending a message to any destination chain with CCIP
// Set the tokens and amounts to transfer
Client.EVMTokenAmount[] memory tokenAmounts = new Client.EVMTokenAmount;
Client.EVMTokenAmount memory tokenAmount = Client.EVMTokenAmount({
// Create an EVM2AnyMessage struct in memory to send via CCIP
Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
receiver: abi.encode(_receiver), // Receiver (EOA) at destination
data: "", // No data to send
tokenAmounts: tokenAmounts, // ERC20 tokens and amounts
extraArgs: Client._argsToBytes( // Optional parameters
gasLimit: 0, // gasLimit = 0 because EOA
strict: false}) // No strict sequencing
feeToken: address(_addressLink) // Setting feeToken to LINK
// approve the Router to spend tokens on sender contract's behalf.
// Send the message through the router and store the returned message ID
bytes32 messageId = router.ccipSend(
// Create an EVM2AnyMessage struct in memory to send via CCIP
Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
receiver: abi.encode(_receiver), // Receiver contract at destination
data: abi.encode("Hello world!"), // Send "Hello world!"
tokenAmounts: new Client.EVMTokenAmount, // No tokens to be sent
extraArgs: "", // Use default values
feeToken: address(_addressLink) // Setting feeToken to LINK
// Send the message through the router and store the returned message ID
bytes32 messageId = router.ccipSend(
## CCIP is the only interoperability protocol with level-5 security
[## Purpose-built for token transfers
With CCIP token transfers, your protocol can start transferring tokens across chains in a fraction of the time it would take for you to build a solution on your own. CCIP provides audited token pool contracts that handle the complexity of burning/minting or locking/minting of your token across chains. Importantly, token sponsors maintain full control over their token pool contract while using CCIP.
In addition to providing fully audited token pool smart contracts, CCIP token transfers have additional security features, such as rate limits that allow you to cap the value transferred over a given time interval. CCIP rate limits are configurable per-token-pool and per-lane and are set up in alignment with the token issuer. This feature is part of the heavily-audited CCIP code base and is only available for CCIP token transfers and not arbitrary messaging.
CCIP token transfers increase the utility of your token, helping you seamlessly scale your userbase across many chains. Tokens transferred through CCIP are highly composable, allowing your ecosystem partners to transfer and build new capabilities with your token via a single CCIP interface.
## Introducing the Risk Management Network
An independent network of nodes that enhances CCIP security by acting as a secondary validation service and detecting and halting anomalous activity.
[## Unlock a wide variety of cross-chain use cases
Use CasesTransfer tokensGamingWeb3 usernamesDeFiLiquidation protection## Transfer tokens
CCIP enables users to programmatically transfer tokens from one blockchain to another via lock-and-mint or burn-and-mint mechanisms, along with attaching arbitrary data commands.
View example in docs tokenAmounts = [
// Encoding the data
const functionSelector = ethers.utils.id("CCIP EVMExtraArgsV1").slice(0, 10);
// "extraArgs" is a structure that can be represented as [ 'uint256', 'bool' ]
// extraArgs are { gasLimit: 0, strict: false }
// we set gasLimit specifically to 0 because we are not sending any data so we are not expecting a receiving contract to handle data
const extraArgs = ethers.utils.defaultAbiCoder.encode(
const encodedExtraArgs = functionSelector + extraArgs.slice(2);
const message = {
data: "0x", // no data
feeToken: feeTokenAddress ? feeTokenAddress : ethers.constants.AddressZero, // If fee token address is provided then fees must be paid in fee token.
CCIP allows interoperability between Web3 games across multiple different blockchains, which enables players on one chain to play a game against players on another chain.
View example in docs uniqueId = keccak256(abi.encodePacked(block.timestamp, msg.sender));
CCIP brings complete interoperability to Web3 naming protocols by enabling users to register onchain names on one chain and propagate these names across other blockchains.
View example in docs ICrossChainNameServiceLookup {
function register(string memory _name, address _address) external;
) external override onlyRouter onlyFromSourceChain(message.sourceChainSelector) {
(string memory _name, address _address) = abi.decode(
CCIP enables DeFi applications to use tokens on one chain as collateral for DeFi applications on another chain, unlocking native cross-chain lending markets.
View example in docs messageId = any2EvmMessage.messageId; // fetch the messageId
uint64 sourceChainSelector = any2EvmMessage.sourceChainSelector; // fetch the source chain identifier (aka selector)
address sender = abi.decode(any2EvmMessage.sender, (address)); // abi-decoding of the sender address
// Collect tokens transferred. This increases this contract's balance for that Token.
Client.EVMTokenAmount[] memory tokenAmounts = any2EvmMessage
address token = tokenAmounts[0].token;
uint256 amount = tokenAmounts[0].amount;
address depositor = abi.decode(any2EvmMessage.data, (address)); // abi-decoding of the depositor's address
MessageIn memory detail = MessageIn(
// Store depositor data.
## DeFi liquidation protection
CCIP can help protect positions held in DeFi protocols across multiple chains by automatically sending assets from one chain to DeFi protocols on another chain to prevent liquidations.
View example in docs messageId = receivedMessage.messageId;
uint64 sourceChainSelector = receivedMessage.sourceChainSelector;
address sender = abi.decode(receivedMessage.sender, (address));
(address tokenAddress, uint256 amount) = abi.decode(
tokenAmounts[1] = (Client.EVMTokenAmount(tokenAddress, amount));
Client.EVM2AnyMessage memory messageReply = Client.EVM2AnyMessage({
CCIP supported networks![Arbitrum network icon network icon]( network icon]( network icon]( icon]( network icon]( chain icon]( icon]( network icon]( icon]( logo icon]( icon]( icon]( icon]( logo]( logo]( logo](## Featured CCIP-Powered Bridges
A cross-chain protocol enabling seamless digital asset transfers across chains.
Launch app]( logo](### Transporter
A hyper-secure bridging app built in association with the Chainlink Foundation, with support from Chainlink Labs.
Launch app](## Future-proof your Web3 strategy
[Start building today](### Talk to an expert
Discuss technical considerations and request integration support.](### Join the masterclass
Watch tutorials and learn how to get started with Chainlink CCIP.](### Ask technical questions
Ask experienced developers on the Community Discord.](### Additional Resources
[.## Get the latest Chainlink content straight to your inbox.
Email AddressYes, I agree to receive email communications from Chainlink.Thank you for signing up! Please check your inbox to confirm your subscription.![ Something went wrong while submitting the form. Please try again### Developers
* Use Cross-Chain (CCIP) 
* Use Data Feeds 
* Use Randomness (VRF) 
* Market and Data Feeds
* Proof of Reserve
* Become an Advocate
* Code of Conduct
* What Is DeFi?
* What Is an Oracle?
* What Is a Smart Contract?
* What Is an NFT?
* What Is Web3?
* What is Asset Tokenization?
* Careers ARE HIRING!
* Talk to an Expert
[Home
Privacy PolicyTerms of Service
(opens a new window)