O espaço dinâmico de desenvolvimento Web3 é o lar de vários provedores de API Web3, que trazem seus pontos fortes e fracos exclusivos para a mesa. Com essa abundância de opções de API, pode ser um desafio determinar quais APIs melhor atendem às suas necessidades de desenvolvimento. E embora possa parecer que a maioria dos fornecedores oferece produtos semelhantes, comparar diferentes APIs Web3 muitas vezes pode ser como comparar maçãs com laranjas.
Então, de todos os provedores de API Web3, qual é a melhor opção? Para descobrir, acompanhe este guia enquanto conduzimos uma análise comparativa dos principais provedores de API do setor Web3: Moralis, Alchemy e QuickNode. À medida que avançamos, analisaremos cuidadosamente esses três fornecedores do ponto de vista de acessibilidade, desempenho e custo.
Ao longo deste guia, você descobrirá rapidamente que Moralis fornece as APIs Web3 mais abrangentes do setor. Consequentemente, Moralis facilita a experiência de desenvolvedor mais acessível e direta do setor. Então, se você deseja começar imediatamente a usar as APIs Web3 de nível superior da Moralis, clique no botão abaixo!
Para saber mais sobre por que Moralis supera a concorrência, junte-se a nós abaixo enquanto mergulhamos direto em nossa comparação de provedores de API Web3!
Comparando APIs Web3: Moralis x Alchemy x QuickNode
Para destacar as semelhanças e, mais importante, as diferenças entre Moralis, Alchemy e QuickNode, usamos as respectivas APIs Web3 de cada provedor para consultar os dados necessários para construir uma visão de portfólio dos tokens ERC-20 de Vitalik Buterin. Nesse caso, uma visualização do portfólio inclui o nome, logotipo, saldo e preço de todos os ativos da carteira.
Optamos pela carteira Vitalik devido ao seu tamanho e à grande quantidade de tokens que contém. Isso o torna o candidato perfeito para testar a disponibilidade de classificações de spam e metadados para grandes conjuntos de tokens. Esta abordagem também nos permitiu avaliar e comparar sistematicamente a acessibilidade, eficiência e relação custo-benefício de Moralis, Alchemy e QuickNode ao buscar os mesmos recursos na cadeia.
Você encontrará os resultados de nossos testes resumidos nos dois gráficos abaixo:
Ao analisar os gráficos acima, você notará que construir uma visão de portfólio dos tokens ERC-20 da Vitalik com Moralis exige significativamente menos chamadas de API e é mais econômico do que utilizar Alchemy e QuickNode.
Com apenas 18 chamadas a um custo total de US$ 0,000882, conseguimos obter o saldo, os metadados e o preço dos tokens ERC-20 da Vitalik. Em comparação, a mesma tarefa exigiu 4.963 chamadas a um preço total de US$ 0,0049189 com Alchemy. E 4.760 chamadas a um custo total de US$ 0,0163091 com QuickNode.
Aqui estão os dados divididos em uma tabela:
Por que Moralis supera a concorrência?
Todas as APIs Web3 da Moralis são orientadas a resultados e projetadas para minimizar o número de chamadas necessárias para consultar dados de blockchain. Enriquecemos todas as nossas respostas de API com decodificações de transações, metadados, etiquetas de endereço, dados de mercado e muito mais de diversas fontes.
Para exemplificar, ao usar a API Token da Moralis e o endpoint de saldo de token, você obtém os saldos ERC-20 de uma carteira – junto com metadados e preços de cada token – em uma única resposta. Isso significa que você só precisa ligar para um endpoint e usar um provedor, simplificando significativamente seus esforços de desenvolvimento.
Em comparação, ao usar provedores como Alchemy e QuickNode, você deve primeiro buscar os saldos de tokens da carteira. A partir daí, você precisa fazer chamadas individuais para consultar os metadados de cada token separadamente. Além disso, as respostas da API do Alchemy e do QuickNode não incluem preços de tokens, o que significa que você também deve envolver um provedor terceirizado como CoinGecko ou CoinMarketCap para obter esses dados.
É por isso que precisamos apenas de 18 ligações para construir uma visão do portfólio dos ERC-20 de Vitalik ao trabalhar com Moralis. Enquanto isso, a mesma tarefa exigia milhares de chamadas e vários provedores ao usar Alchemy ou QuickNode.
Para detalhar e esclarecer ainda mais, vamos examinar detalhadamente os endpoints e as respostas de cada provedor que utilizamos para renderizar a visão do portfólio dos tokens ERC-20 da Vitalik.
Moralis – Visão geral do endpoint
Com as APIs abrangentes da Moralis, precisamos apenas do endpoint Token Balance para buscar os saldos de tokens – junto com metadados e preços – de qualquer endereço:
OBTENHA https://deep-index.moralis.io/api/v2.2/wallets/0xd8da6bf26964af9d7eed9e03e53415d37aa96045/tokens?chain=eth
Aqui está um exemplo de como seria a resposta:
{ “cursor”: null, “página”: 0, “page_size”: 100, “resultado”: ( { “token_address”: “0xdac17f958d2ee523a2206206994597c13d831ec7”, “symbol”: “USDT”, “nome”: “Tether USD”, “logo”: ” “thumbnail”: ” “decimais”: 6, “balance”: “517438540”, “possible_spam”: false, “verified_contract”: true, “balance_formatted”: “517.43854”, “usd_price”: 1.0006571224951815, “usd_price_24hr_percent_change”: 0,08795941027880547, “usd_price_24hr_usd_change”: 0,45543496836985303, “usd_value”: 517,7785605045078, “native_token”: falso, “portfolio_percentage”: 0 } , //… ) }
Esta resposta é enriquecida com uma abundância de dados úteis, incluindo símbolo, nome, logotipo, preço, saldo, mudanças de preço ao longo do tempo e muito mais de cada token. Assim, ao trabalhar com Moralis, você só precisa de um único endpoint para buscar todos os dados necessários para construir uma visão completa do portfólio ERC-20!
Alquimia – Visão Geral dos Endpoints
Ao usar o Alchemy, inicialmente precisamos chamar o endpoint getTokenBalances(), que é usado para buscar os saldos de tokens de uma carteira:
alchemy.core.getTokenBalances(“0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045”)
Em troca, você receberá uma resposta simples contendo uma série de saldos de tokens, apresentando apenas o endereço do contrato e o saldo de tokens em hexadecimal:
“jsonrpc”: “2.0”, “id”: 1, “resultado”: { “endereço”: “0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5”, “tokenBalances”: ( { “contractAddress”: “0x0183736842388dcc6d41674082937684056a3 904”, “tokenBalance”: “0x00000000000000000000000000000000000001581113dffdc72c05ad16068” }, //… ) } }
Além do mais, além de fornecer uma resposta bastante limitada, Alchemy inclui adicionalmente alguns tokens com saldo igual a zero:
{ “contractAddress”: “0x007f252591528d326b2a73b366e5c6a0aa5128cc”, “tokenBalance”: “0x00000000000000000000000000000000000000000000000000000000000 0”}
Incluir tokens com saldo zero é totalmente desnecessário e diminui ainda mais o tempo necessário para buscar todos os tokens usando a API do Alchemy.
Assim que tivermos o equilíbrio, agora também precisamos chamar o endpoint getTokenMetadata() do Alchemy separadamente para cada token individual. Isso resultará em milhares e milhares de chamadas adicionais. Aqui está um exemplo da aparência do endpoint:
contrato const = “0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48”; alquimia.core.getTokenMetadata(contrato).then(console.log);
Em troca, você receberá uma resposta contendo decimais, logotipo, nome e símbolo de um único token:
{ “jsonrpc”: “2.0”, “id”: 1, “resultado”: { “decimais”: 6, “logotipo”: ” “nome”: “USDC”, “símbolo”: “USDC” } }
Por último, você precisa utilizar um fornecedor terceirizado, como CoinGecko ou CoinMarketCap, para obter o preço de cada token. Esta é outra etapa incômoda, resultando em mais chamadas e um fluxo de trabalho mais complexo para você e sua equipe de desenvolvimento!
QuickNode – Visão geral dos terminais
Ao usar QuickNode, também temos que começar chamando seu endpoint getWalletTokenBalance para buscar os saldos de token ERC-20 da carteira:
curl \ -X POST \ -H “Tipo de conteúdo: aplicativo/json” \ –data ‘{ “id”:67, “jsonrpc”:”2.0″, “método”:”qn_getWalletTokenBalance”, “params”: ( { “carteira”: “0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045” }) }’
Isso retorna uma matriz de tokens semelhante a esta:
{ “jsonrpc”: “2.0”, “id”: 67, “resultado”: { “resultado”: ( { “nome”: “Crédito de serviço Namefi”, “símbolo”: “NFSC”, “decimais”: “18 “, “endereço”: “0x0000000000c39a0f674c12a5e63eb8031b550b6f”, “quantityIn”: “100000000000000000000”, “quantityOut”: “20000000000000000000”, “totalBalance”: “800000000 00000000000” }, //… ) } }
A resposta do QuickNode contém mais informações do que a da Alchemy, mas é insuficiente para construir uma visão abrangente do portfólio. Dessa forma, precisamos chamar o endpoint getTokenMetadataByContractAddress para cada token individual para obter informações adicionais, o que resulta em milhares de chamadas extras:
curl \ -X POST \ -H “Tipo de conteúdo: aplicativo/json” \ –data ‘{ “id”:67, “jsonrpc”:”2.0″, “método”:”qn_getTokenMetadataByContractAddress”, “params”: ( { “contrato”: “0x4d224452801ACEd8B2F0aebE155379bb5D594381” }) }’
Esta é a aparência da resposta:
{ “jsonrpc”: “2.0”, “id”: 67, “resultado”: { “nome”: “Tether USD”, “symbol”: “USDT”, “contractAddress”: “0xdac17f958d2ee523a2206206994597c13d831ec7”, “decimais”: ” 6″, “genesisBlock”: null, “genesisTransaction”: null } }
Além do mais, você notará que a resposta de metadados do QuickNode nem inclui o logotipo do token. Este é outro componente importante para construir uma visão do portfólio de tokens ERC-20.
Finalmente, assim como ao usar o Alchemy, você também precisa aproveitar um fornecedor terceirizado como CoinGecko ou CoinMarketCap para obter preços de tokens ao trabalhar com QuickNode. Como tal, esta é outra integração que complica as coisas para você e sua equipe de desenvolvimento.
Resumo: Comparação completa – Moralis vs. Alchemy vs.
Com as APIs Web3 específicas para casos de uso e orientadas a resultados da Moralis, somos capazes de fornecer uma experiência de desenvolvedor significativamente mais acessível e direta em comparação com Alchemy e QuickNode!
Graças às respostas de API totalmente enriquecidas de Moralis, você só precisa de um único endpoint e 18 chamadas de API para obter saldos de tokens, metadados, preços e muito mais da carteira de Vitalik. Isto melhora significativamente o desempenho e a relação custo-benefício das APIs Web3 da Moralis. Você precisa de menos chamadas para consultar os dados necessários.
Em comparação, com Alchemy e QuickNode, a mesma tarefa requer milhares de chamadas e envolvimento de terceiros. Provedores como CoinGecko ou CoinMarketCap são necessários, transformando esta tarefa simples em um empreendimento incômodo e demorado.
Embora esta comparação use a API Token da Moralis como exemplo, é importante notar que todas as nossas APIs, incluindo a API NFT, API Wallet, etc., são igualmente abrangentes e fáceis de usar. Como tal, não importa se você está construindo uma visão de portfólio de tokens ERC-20, uma plataforma baseada em NFT, um rastreador de preços criptográficos ou qualquer outro projeto Web3; Moralis supera continuamente a concorrência.
Então, se você deseja começar a construir projetos Web3 com mais rapidez e eficiência, inscreva-se no Moralis!
