Aptos - Next-Generation Layer 1 Blockchain

Aptos RPC
With Dwellir, you get access to our global Aptos network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Try Free →

Why Build on Aptos?

Aptos is a next-generation Layer 1 blockchain designed for safety, scalability, and upgradeability. Built by former Meta engineers using the Move programming language, Aptos delivers unprecedented performance and security for Web3 applications.

⚡ Unmatched Performance

• 160,000+ TPS peak throughput - Industry-leading transaction processing
• Sub-second finality - Near-instant transaction confirmation
• Parallel execution engine - Block-STM technology for maximum efficiency

🛡️ Move-Powered Security

• Resource-oriented architecture - Assets as first-class citizens
• Formal verification - Mathematical proof of code correctness
• Built-in safety - Prevents common vulnerabilities by design

🚀 Developer-First Design

• Upgradeable smart contracts - Seamless contract evolution
• Native token standards - Built-in fungible & NFT support
• Rich SDK ecosystem - TypeScript, Python, Rust, and more

Quick Start with Aptos

Connect to Aptos in seconds with Dwellir's optimized endpoints:

🔗 RPC Endpoints

Aptos Mainnet (Chain ID: 1)Live

https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY

✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

curl -X GET https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY \
  -H "Accept: application/json"

Installation & Setup

TypeScript SDK

import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";

// Connect to Aptos mainnet
const config = new AptosConfig({
  network: Network.MAINNET,
  fullnode: "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY",
});

const aptos = new Aptos(config);

// Get chain information
const ledgerInfo = await aptos.getLedgerInfo();
console.log("Chain ID:", ledgerInfo.chain_id);
console.log("Latest version:", ledgerInfo.ledger_version);

// Query account balance
const accountAddress = "0x1";
const resources = await aptos.getAccountResources({ accountAddress });
const aptosCoin = resources.find(
  r => r.type === "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>"
);
console.log("APT Balance:", aptosCoin?.data?.coin?.value);

Python SDK

from aptos_sdk.client import RestClient

# Connect to Aptos mainnet
client = RestClient(
    "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY"
)

# Get chain information
ledger_info = client.get_ledger_info()
print(f"Chain ID: {ledger_info['chain_id']}")
print(f"Latest version: {ledger_info['ledger_version']}")

# Query account balance
account_address = "0x1"
resources = client.account_resources(account_address)
for resource in resources:
    if resource["type"] == "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>":
        balance = resource["data"]["coin"]["value"]
        print(f"APT Balance: {balance}")

REST API

# Get ledger information
curl -X GET "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY" \
  -H "Accept: application/json"

# Get account information
curl -X GET "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY/accounts/0x1" \
  -H "Accept: application/json"

# Get account resources
curl -X GET "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY/accounts/0x1/resources" \
  -H "Accept: application/json"

Network Information

Chain ID

1

Mainnet

Block Time

~1 second

Average

Native Token

APT

Aptos Coin

Consensus

AptosBFT v4

Byzantine Fault Tolerant

REST API Reference

Aptos provides a comprehensive REST API for interacting with the blockchain. Access account data, submit transactions, query events, and more.

Available REST API Endpoints

📊 Account Methods

Query account data and resources

GET /accounts/{address}

Get account information

GET /accounts/{address}/resources

Get all account resources

GET /accounts/{address}/modules

Get deployed Move modules

💳 Transaction Methods

Submit and query transactions

POST /transactions

Submit signed transaction

POST /transactions/simulate

Simulate transaction execution

GET /transactions/by_hash/{hash}

Get transaction by hash

🔍 Block & Event Methods

Query blocks and events

GET /blocks/by_height/{height}

Get block by height

GET /accounts/{address}/events/{creation_number}

Get events by creation number

POST /view

Execute view functions

Ready to build with Move on Aptos?

Get Your Free API Key →

Common Integration Patterns

🔄 Transaction Submission

Submit and monitor transactions on Aptos:

// Build and submit a transaction
async function transferAPT(from: Account, to: string, amount: number) {
  const transaction = await aptos.transaction.build.simple({
    sender: from.accountAddress,
    data: {
      function: "0x1::aptos_account::transfer",
      functionArguments: [to, amount],
    },
  });

  // Sign transaction
  const committedTransaction = await aptos.signAndSubmitTransaction({
    signer: from,
    transaction,
  });

  // Wait for confirmation
  const executedTransaction = await aptos.waitForTransaction({
    transactionHash: committedTransaction.hash,
  });

  return executedTransaction;
}

📊 Resource Queries

Query on-chain resources efficiently:

// Get specific resource type
async function getCoinBalance(address: string, coinType: string) {
  const resource = await aptos.getAccountResource({
    accountAddress: address,
    resourceType: `0x1::coin::CoinStore<${coinType}>`,
  });
  
  return resource.data.coin.value;
}

// Query multiple resources
async function getAccountBalances(address: string) {
  const resources = await aptos.getAccountResources({ 
    accountAddress: address 
  });
  
  const coinStores = resources.filter(r => 
    r.type.includes("0x1::coin::CoinStore")
  );
  
  return coinStores.map(store => ({
    type: store.type,
    balance: store.data.coin.value,
  }));
}

🔍 Event Streaming

Monitor on-chain events in real-time:

// Query events by event handle
async function getTransferEvents(address: string) {
  const events = await aptos.getEvents({
    options: {
      where: {
        account_address: { _eq: address },
      },
    },
  });
  
  return events;
}

// Monitor new events
async function watchEvents(eventHandle: string) {
  let lastSequence = "0";
  
  setInterval(async () => {
    const events = await aptos.getEventsByEventHandle({
      eventHandleStruct: eventHandle,
      minimumLedgerVersion: lastSequence,
    });
    
    for (const event of events) {
      console.log("New event:", event);
      lastSequence = event.sequence_number;
    }
  }, 1000);
}

🎯 View Functions

Call view functions without gas costs:

// Execute view function
async function callViewFunction(
  module: string,
  func: string,
  typeArgs: string[],
  args: any[]
) {
  const result = await aptos.view({
    payload: {
      function: `${module}::${func}`,
      typeArguments: typeArgs,
      functionArguments: args,
    },
  });
  
  return result[0];
}

// Example: Get token balance
async function getTokenBalance(owner: string, tokenId: string) {
  return callViewFunction(
    "0x3::token",
    "balance_of",
    [],
    [owner, tokenId]
  );
}

Performance Best Practices

1. Connection Pooling

Reuse client instances to minimize connection overhead:

// Singleton pattern for Aptos client
class AptosClient {
  private static instance: Aptos;
  
  static getInstance(): Aptos {
    if (!this.instance) {
      const config = new AptosConfig({
        network: Network.MAINNET,
        fullnode: "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY",
      });
      this.instance = new Aptos(config);
    }
    return this.instance;
  }
}

2. Batch Operations

Combine multiple operations for efficiency:

// Batch account queries
async function batchGetAccounts(addresses: string[]) {
  const promises = addresses.map(addr => 
    aptos.getAccountInfo({ accountAddress: addr })
  );
  
  return Promise.all(promises);
}

// Parallel resource fetching
async function batchGetResources(addresses: string[]) {
  const results = await Promise.allSettled(
    addresses.map(addr => 
      aptos.getAccountResources({ accountAddress: addr })
    )
  );
  
  return results
    .filter(r => r.status === "fulfilled")
    .map(r => r.value);
}

3. Smart Caching

Cache immutable data to reduce API calls:

class AptosCache {
  private cache = new Map();
  private ttl = 60000; // 1 minute for mutable data
  
  async getAccountResource(address: string, resourceType: string) {
    const key = `${address}:${resourceType}`;
    const cached = this.cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.data;
    }
    
    const resource = await aptos.getAccountResource({
      accountAddress: address,
      resourceType,
    });
    
    this.cache.set(key, {
      data: resource,
      timestamp: Date.now(),
    });
    
    return resource;
  }
}

Transaction Patterns

Simple Transfer

Transfer APT between accounts:

async function transferAPT(
  sender: Account,
  recipient: string,
  amount: number
) {
  const transaction = await aptos.transaction.build.simple({
    sender: sender.accountAddress,
    data: {
      function: "0x1::aptos_account::transfer",
      functionArguments: [recipient, amount],
    },
  });

  const pendingTxn = await aptos.signAndSubmitTransaction({
    signer: sender,
    transaction,
  });

  return aptos.waitForTransaction({
    transactionHash: pendingTxn.hash,
  });
}

Multi-Agent Transaction

Execute transactions requiring multiple signatures:

async function multiAgentTransaction(
  sender: Account,
  secondarySigner: Account,
  payload: any
) {
  const transaction = await aptos.transaction.build.multiAgent({
    sender: sender.accountAddress,
    secondarySignerAddresses: [secondarySigner.accountAddress],
    data: payload,
  });

  // Sender signs first
  const senderAuth = aptos.transaction.sign({
    signer: sender,
    transaction,
  });

  // Secondary signer signs
  const secondaryAuth = aptos.transaction.sign({
    signer: secondarySigner,
    transaction,
  });

  // Submit with both signatures
  const pendingTxn = await aptos.transaction.submit.multiAgent({
    transaction,
    senderAuthenticator: senderAuth,
    additionalSignersAuthenticators: [secondaryAuth],
  });

  return aptos.waitForTransaction({
    transactionHash: pendingTxn.hash,
  });
}

Sponsored Transaction

Fee payer pattern for gasless transactions:

async function sponsoredTransaction(
  sender: Account,
  sponsor: Account,
  payload: any
) {
  const transaction = await aptos.transaction.build.simple({
    sender: sender.accountAddress,
    data: payload,
    withFeePayer: true,
  });

  // Set fee payer
  transaction.feePayerAddress = sponsor.accountAddress;

  // Sender signs
  const senderAuth = await aptos.transaction.sign({
    signer: sender,
    transaction,
  });

  // Sponsor signs for fees
  const sponsorAuth = await aptos.transaction.signAsFeePayer({
    signer: sponsor,
    transaction,
  });

  // Submit transaction
  const pendingTxn = await aptos.transaction.submit.simple({
    transaction,
    senderAuthenticator: senderAuth,
    feePayerAuthenticator: sponsorAuth,
  });

  return aptos.waitForTransaction({
    transactionHash: pendingTxn.hash,
  });
}

Module Development

Deploy Move Module

Deploy smart contracts to Aptos:

async function deployModule(
  account: Account,
  moduleByteCode: Uint8Array,
  metadata: Uint8Array
) {
  const transaction = await aptos.publishPackageTransaction({
    account: account.accountAddress,
    moduleBytecode: moduleByteCode,
    metadata,
  });

  const pendingTxn = await aptos.signAndSubmitTransaction({
    signer: account,
    transaction,
  });

  return aptos.waitForTransaction({
    transactionHash: pendingTxn.hash,
  });
}

Troubleshooting Common Issues

Error: "Transaction Expired"

Aptos transactions have expiration times. Ensure timely submission:

// Set custom expiration time
const transaction = await aptos.transaction.build.simple({
  sender: sender.accountAddress,
  data: payload,
  options: {
    expireTimestamp: Math.floor(Date.now() / 1000) + 600, // 10 minutes
  },
});

Error: "Insufficient Balance for Gas"

Always account for gas fees in balance checks:

async function checkSufficientBalance(
  address: string,
  amount: number,
  estimatedGas: number = 100000
) {
  const balance = await getCoinBalance(
    address,
    "0x1::aptos_coin::AptosCoin"
  );
  
  const totalRequired = amount + estimatedGas;
  
  if (balance < totalRequired) {
    throw new Error(
      `Insufficient balance. Have: ${balance}, Need: ${totalRequired}`
    );
  }
  
  return true;
}

Error: "Sequence Number Mismatch"

Handle concurrent transactions properly:

class TransactionManager {
  private sequenceNumber: bigint | null = null;
  
  async submitTransaction(account: Account, payload: any) {
    // Get latest sequence number if not cached
    if (!this.sequenceNumber) {
      const accountInfo = await aptos.getAccountInfo({
        accountAddress: account.accountAddress,
      });
      this.sequenceNumber = BigInt(accountInfo.sequence_number);
    }
    
    const transaction = await aptos.transaction.build.simple({
      sender: account.accountAddress,
      data: payload,
      options: {
        accountSequenceNumber: this.sequenceNumber,
      },
    });
    
    // Increment for next transaction
    this.sequenceNumber++;
    
    return aptos.signAndSubmitTransaction({
      signer: account,
      transaction,
    });
  }
}

Migration Guide

From Ethereum/EVM

Key differences when migrating from EVM chains:

// Ethereum (Solidity)
// contract.transfer(recipient, amount)

// Aptos (Move)
const transaction = await aptos.transaction.build.simple({
  sender: sender.accountAddress,
  data: {
    function: "0x1::aptos_account::transfer",
    functionArguments: [recipient, amount],
  },
});

// Key differences:
// ✅ Resource-oriented vs account model
// ✅ Move modules vs smart contracts
// ✅ Parallel execution vs sequential
// ⚠️ Different address format (64 chars vs 40)
// ⚠️ No msg.sender - explicit signer required
// ⚠️ Resources vs mappings for storage

Resources & Tools

Official Resources

• Aptos Documentation
• Aptos Explorer
• Move Language Book
• Aptos GitHub

Developer Tools

• Aptos CLI
• Petra Wallet
• Move Playground
• Aptos SDK Libraries

Need Help?

• 📧 Email: support@dwellir.com
• 📚 Docs: You're here!
• 🎯 Dashboard: dashboard.dwellir.com

---

Start building on Aptos with Dwellir's enterprise-grade RPC infrastructure. Get your free API key →