Moralis 2026: 100K+ DApp에 실시간 온체인 데이터를 제공하는 Web3 데이터 API — 설정 가이드

# .env
MORALIS_API_KEY=your_api_key_here

// server.js
require('dotenv').config();
const apiKey = process.env.MORALIS_API_KEY;
if (!apiKey) {
  throw new Error('MORALIS_API_KEY is not defined');
}

npm install moralis

// Node.js 애플리케이션에서 Moralis 초기화
const Moralis = require('moralis').default;

await Moralis.start({
  apiKey: process.env.MORALIS_API_KEY,
});

console.log('Moralis SDK initialized successfully');

pip install moralis

# Python에서 Moralis 초기화
from moralis import evm_api
import os

api_key = os.environ.get('MORALIS_API_KEY')
if not api_key:
    raise ValueError("MORALIS_API_KEY environment variable is required")

print("Moralis Python SDK ready")

// Unity C# 초기화
using MoralisUnity;
using MoralisUnity.Web3Api.Client;

async void Start()
{
    MoralisClient moralis = new MoralisClient(
        hostUrl: "https://deep-index.moralis.io/api/v2",
        applicationId: "your_app_id"
    );
    await moralis.StartAsync();
    Debug.Log("Moralis Unity SDK initialized");
}

const priceResponse = await Moralis.EvmApi.token.getTokenPrice({
  address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  chain: '0x1', // Ethereum 메인넷
});

console.log('Token Price:', priceResponse.result.usdPrice);
console.log('Price Change 24h:', priceResponse.result.usdPricePercentChange24h);

const balances = await Moralis.EvmApi.token.getWalletTokenBalances({
  address: '0x1234567890123456789012345678901234567890',
  chain: '0x1',
});

balances.result.forEach((token) => {
  console.log(`${token.name}: ${token.balance} (${token.symbol})`);
});

const transfers = await Moralis.EvmApi.token.getWalletTokenTransfers({
  address: '0x1234567890123456789012345678901234567890',
  chain: '0x1',
  limit: 10,
});

transfers.result.forEach((tx) => {
  console.log(`From: ${tx.fromAddress} To: ${tx.toAddress} Amount: ${tx.value}`);
});

const metadata = await Moralis.EvmApi.token.getTokenMetadata({
  addresses: [
    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
    '0x6B175474E89094C44Da98b954EedeAC495271d0F',
  ],
  chain: '0x1',
});

metadata.result.forEach((token) => {
  console.log(`${token.name} (${token.symbol}) - ${token.decimals} decimals`);
});

const nfts = await Moralis.EvmApi.nft.getWalletNFTs({
  address: '0x1234567890123456789012345678901234567890',
  chain: '0x1',
  limit: 20,
});

nfts.result.forEach((nft) => {
  console.log(`Collection: ${nft.name} Token ID: ${nft.tokenId}`);
  console.log(`Metadata: ${nft.metadata}`);
});

const nftMetadata = await Moralis.EvmApi.nft.getNFTMetadata({
  address: '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D',
  tokenId: '1',
  chain: '0x1',
});

console.log('Name:', nftMetadata.result.name);
console.log('Image:', nftMetadata.result.metadata?.image);
console.log('Attributes:', nftMetadata.result.metadata?.attributes);

const transfers = await Moralis.EvmApi.nft.getNFTContractTransfers({
  address: '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D',
  chain: '0x1',
  limit: 10,
});

transfers.result.forEach((tx) => {
  console.log(`Token ${tx.tokenId}: ${tx.fromAddress} -> ${tx.toAddress}`);
});

from moralis import evm_api

params = {
    "address": "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D",
    "chain": "eth"
}

result = evm_api.nft.get_nft_floor_price(
    api_key=api_key,
    params=params,
)

print(f"Floor Price: {result['floor_price']} ETH")

const { EvmChain } = require('@moralisweb3/common-evm-utils');

const stream = {
  chains: [EvmChain.ETHEREUM, EvmChain.POLYGON],
  description: 'Track USDC transfers',
  tag: 'usdc_transfers',
  includeNativeTxs: false,
  webhookUrl: 'https://your-app.com/webhooks/moralis',
  includeContractLogs: true,
  abi: [
    {
      anonymous: false,
      inputs: [
        { indexed: true, name: 'from', type: 'address' },
        { indexed: true, name: 'to', type: 'address' },
        { indexed: false, name: 'value', type: 'uint256' },
      ],
      name: 'Transfer',
      type: 'event',
    },
  ],
  topic0: ['Transfer(address,address,uint256)'],
  filter: {
    'address': '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  },
  includeInternalTxs: false,
};

const newStream = await Moralis.Streams.add(stream);
console.log('Stream created:', newStream.result.id);

// Express 웹훅 핸들러
const express = require('express');
const crypto = require('crypto');
const app = express();
app.use(express.json());

app.post('/webhooks/moralis', (req, res) => {
  // 보안을 위해 웹훅 서명 확인
  const signature = req.headers['x-signature'];
  const body = JSON.stringify(req.body);
  const hash = crypto
    .createHmac('sha256', process.env.MORALIS_STREAM_SECRET)
    .update(body)
    .digest('hex');

  if (signature !== hash) {
    return res.status(401).send('Unauthorized');
  }

  const events = req.body.confirmed || req.body.unconfirmed;
  events.forEach((event) => {
    console.log('Transfer detected:', {
      from: event.from,
      to: event.to,
      value: event.value,
      transactionHash: event.transactionHash,
    });
  });

  res.status(200).send('OK');
});

app.listen(3000, () => console.log('Webhook server running on port 3000'));

const { EvmChain } = require('@moralisweb3/common-evm-utils');

const authMessage = await Moralis.Auth.requestMessage({
  chain: EvmChain.ETHEREUM,
  address: '0x1234567890123456789012345678901234567890',
  network: 'evm',
  domain: 'your-app.com',
  statement: 'Sign this message to authenticate with Your App',
  uri: 'https://your-app.com/login',
  expirationTime: new Date(Date.now() + 86400000), // 24시간
  timeout: 60,
});

console.log('Sign-in message:', authMessage.result.message);

const authResult = await Moralis.Auth.verify({
  network: 'evm',
  message: authMessage.result.message,
  signature: '0x...signed_message...',
});

console.log('Authenticated user:', authResult.result.profileId);
console.log('Address:', authResult.result.address);

const chains = ['0x1', '0x89', '0x38', '0xa4b1']; // ETH, MATIC, BNB, ARB
const address = '0x1234567890123456789012345678901234567890';

const portfolio = {};

for (const chain of chains) {
  const balances = await Moralis.EvmApi.token.getWalletTokenBalances({
    address,
    chain,
  });
  
  const chainName = chain === '0x1' ? 'Ethereum'
    : chain === '0x89' ? 'Polygon'
    : chain === '0x38' ? 'BNB Chain'
    : 'Arbitrum';
  
  portfolio[chainName] = balances.result.map((t) => ({
    symbol: t.symbol,
    balance: t.balance,
    usdValue: t.usdPrice ? parseFloat(t.balance) * t.usdPrice : null,
  }));
}

console.log('Multi-chain portfolio:', JSON.stringify(portfolio, null, 2));

let cursor = null;
const allTransfers = [];

do {
  const response = await Moralis.EvmApi.token.getWalletTokenTransfers({
    address: '0x1234567890123456789012345678901234567890',
    chain: '0x1',
    limit: 100,
    cursor,
  });

  allTransfers.push(...response.result);
  cursor = response.pagination.cursor;
} while (cursor);

console.log(`Retrieved ${allTransfers.length} transfers`);

const axios = require('axios');
const rateLimit = require('axios-rate-limit');

const http = rateLimit(axios.create(), {
  maxRequests: 25,
  perMilliseconds: 1000,
});

async function safeApiCall(apiFunction) {
  try {
    return await apiFunction();
  } catch (error) {
    if (error.status === 429) {
      // 속도 제한 - 지수 백오프 구현
      await new Promise((r) => setTimeout(r, 2000));
      return safeApiCall(apiFunction);
    }
    throw error;
  }
}

const Redis = require('ioredis');
const redis = new Redis();

async function getCachedTokenPrice(tokenAddress, chain) {
  const cacheKey = `price:${chain}:${tokenAddress}`;
  const cached = await redis.get(cacheKey);
  
  if (cached) {
    return JSON.parse(cached);
  }

  const price = await Moralis.EvmApi.token.getTokenPrice({
    address: tokenAddress,
    chain,
  });

  // 60초 동안 캐싱
  await redis.setex(cacheKey, 60, JSON.stringify(price.result));
  return price.result;
}