Introduction
If you are building with Moralis, the platform handles a big part of the blockchain data layer for you. It helps with wallet-based authentication, on-chain data access, NFT data, token balances, streams, and multi-chain backend workflows.
But Moralis rarely works alone in production. Most teams pair it with other tools for wallet connection, indexing edge cases, smart contract deployment, storage, analytics, notifications, and frontend delivery.
This article covers the best tools to use with Moralis, grouped by real startup use case. It also explains where each tool fits, when it works well, and where the trade-offs show up.
Quick Answer
- WalletConnect is one of the best wallet connection layers to pair with Moralis for mobile and cross-wallet onboarding.
- IPFS works well with Moralis for NFT metadata, media storage, and decentralized asset delivery.
- Alchemy or Infura can complement Moralis when you need raw RPC access, archive node behavior, or protocol-specific endpoints.
- The Graph is useful with Moralis when your app needs custom indexed views that Moralis APIs do not expose cleanly.
- OpenZeppelin is a strong fit for contract security libraries, audits, and upgradeable contract patterns around a Moralis-powered app.
- Vercel, Next.js, and PostHog are practical additions for frontend deployment, product analytics, and growth loops.
Best Tools to Use With Moralis
1. WalletConnect
Best for: wallet onboarding across mobile and desktop
Moralis helps with Web3 auth and backend user handling, but WalletConnect improves the actual wallet connection experience. This matters when your users are not all on MetaMask desktop.
For consumer apps, NFT platforms, and mobile-first products, WalletConnect reduces friction across wallets like Rainbow, Trust Wallet, Ledger Live, and MetaMask Mobile.
- Works well for multi-wallet support
- Useful for cross-device session handoff
- Pairs well with Moralis authentication flows
When this works: consumer apps, NFT mint pages, token-gated communities, wallets with non-technical users.
When it fails: if your team assumes wallet connection alone solves onboarding. It does not fix chain confusion, gas anxiety, or signature trust issues.
Trade-off: better reach, but more UI states and wallet-specific edge cases to test.
2. IPFS
Best for: NFT metadata and decentralized file storage
Moralis gives you rich NFT and token data, but you still need a reliable place to store metadata JSON, images, video, or documents. IPFS is the usual fit.
For NFT marketplaces, digital identity apps, and collectibles, Moralis plus IPFS is a common stack. Moralis handles indexing and querying. IPFS handles content persistence and decentralized access patterns.
- Supports NFT metadata workflows
- Useful for immutable media references
- Reduces dependence on centralized file servers
When this works: NFT apps, credential storage references, decentralized media, on-chain/off-chain hybrid products.
When it fails: if you treat IPFS as fully managed permanent storage without a pinning strategy. Content availability can degrade.
Trade-off: stronger decentralization, but more operational thinking around pinning, gateways, and content delivery.
3. Alchemy
Best for: raw RPC access and chain-specific infrastructure depth
Moralis is strong for indexed APIs and developer speed. Alchemy becomes useful when you need lower-level blockchain access, transaction simulation, mempool visibility, enhanced debugging, or chain-specific tooling.
Many teams use Moralis for data products and Alchemy for infrastructure-heavy transaction paths.
- Good for raw node access
- Useful for debugging and simulation
- Helps when your app needs direct RPC behavior
When this works: DeFi apps, transaction-heavy systems, bots, smart wallet apps, protocol dashboards.
When it fails: if the team duplicates too much functionality across both tools and ends up with a confusing architecture.
Trade-off: more flexibility, but more integration complexity and potentially higher infra cost.
4. Infura
Best for: Ethereum and IPFS infrastructure compatibility
Infura is still a practical complement to Moralis for teams that already rely on Ethereum ecosystem tooling built around Infura endpoints. It is especially useful if your stack spans both node access and IPFS services.
Infura is less about replacing Moralis and more about filling gaps where direct endpoint control matters.
- Useful for Ethereum RPC workflows
- Can support IPFS-related workflows
- Common in legacy Web3 stacks
When this works: Ethereum-centric apps, established developer teams, products migrating from older Web3 stacks.
When it fails: if your app is highly multi-chain and you expect one provider to fit every chain equally well.
Trade-off: mature ecosystem fit, but less product-level abstraction than Moralis provides.
5. The Graph
Best for: custom indexed queries for protocol-specific data
Moralis covers many common API needs out of the box. But when your app depends on very custom entity relationships, event-derived states, or domain-specific dashboards, The Graph can be the better fit.
Founders often miss this point: Moralis is fast for broad data access, while The Graph is stronger when your business logic depends on your own indexing model.
- Supports protocol-specific querying
- Useful for event-heavy smart contracts
- Good for analytics and governance interfaces
When this works: DAOs, DeFi analytics, staking dashboards, protocol back offices.
When it fails: if you do not have the engineering bandwidth to maintain subgraphs and data consistency.
Trade-off: precision and flexibility, but more maintenance than using a prebuilt API layer.
6. OpenZeppelin
Best for: secure smart contract development
Moralis does not replace contract security. If your product includes token contracts, marketplaces, access controls, or upgradeable logic, OpenZeppelin should be part of the stack.
This is especially important for startups shipping MVPs under time pressure. Reusing audited primitives is usually safer than writing custom permission logic from scratch.
- Provides audited contract libraries
- Supports upgradeable contract patterns
- Improves security posture early
When this works: token launches, NFT contracts, DAO tools, on-chain games, vault logic.
When it fails: if teams use upgradeability without governance discipline. The contract is safer, but the trust model gets weaker.
Trade-off: faster and safer development, but less room for unusual low-level optimization.
7. Ethers.js
Best for: contract interaction in frontend and backend apps
Even with Moralis APIs, you often still need direct smart contract reads, writes, event listeners, and signer logic. Ethers.js remains one of the most practical libraries for this.
Use Moralis for indexed data and wallet auth. Use Ethers.js when you need exact contract-level behavior.
- Clean contract interaction layer
- Works well with WalletConnect and MetaMask flows
- Useful for frontend and server-side scripts
When this works: dApps with direct transaction flows, claim pages, staking interfaces, admin tools.
When it fails: if the team uses it for heavy historical indexing that Moralis already solves better.
Trade-off: strong developer control, but more low-level handling than API-first workflows.
8. Next.js
Best for: Web3 frontends with SEO, SSR, and fast iteration
Next.js is a strong frontend layer for Moralis-powered apps. It helps when your product needs landing pages, token pages, wallet dashboards, and server-side rendering.
This matters more than many Web3 teams expect. If your app depends on organic discovery, fast page delivery, or indexable content, framework choice affects growth.
- Supports SEO-friendly routing
- Good for hybrid Web2 and Web3 product pages
- Works well with Vercel deployment
When this works: NFT platforms, Web3 SaaS tools, analytics products, token discovery pages.
When it fails: if the team overcomplicates SSR for data that could be fetched client-side after wallet connection.
Trade-off: better flexibility and performance, but more architectural decisions around rendering and caching.
9. Vercel
Best for: fast deployment of Moralis-powered frontends
Vercel is often the simplest way to deploy a Next.js app that uses Moralis APIs. Startups like it because it shortens the path from prototype to production.
It is especially effective for frontend-heavy products that do not need a complex DevOps layer on day one.
- Fast deployment workflow
- Good preview environments for teams
- Works well with modern Jamstack patterns
When this works: MVPs, early-stage products, marketing-plus-app experiences, internal dashboards.
When it fails: if you expect Vercel alone to solve backend reliability, long-running jobs, or blockchain event processing.
Trade-off: excellent speed, but not a full infrastructure replacement.
10. PostHog
Best for: product analytics in wallet-based apps
Moralis tells you what happened on-chain. PostHog helps explain what happened in the product before and after the chain event. That difference matters.
For example, if users connect wallets but never sign, Moralis sees part of the flow. PostHog reveals where UI friction actually starts.
- Tracks off-chain user behavior
- Useful for funnel analysis
- Supports experimentation and retention analysis
When this works: any startup trying to improve activation, conversion, and wallet retention.
When it fails: if you track only vanity events and never map analytics to revenue or protocol actions.
Trade-off: better product decisions, but extra work around event taxonomy and privacy handling.
Tools by Use Case
| Use Case | Best Tool With Moralis | Why It Fits |
|---|---|---|
| Wallet onboarding | WalletConnect | Improves wallet compatibility and mobile UX |
| NFT metadata storage | IPFS | Supports decentralized media and metadata delivery |
| Raw blockchain access | Alchemy | Adds direct RPC and simulation capabilities |
| Ethereum infrastructure | Infura | Common endpoint layer for Ethereum-based apps |
| Custom data indexing | The Graph | Builds custom query models from contract events |
| Contract security | OpenZeppelin | Provides audited smart contract standards |
| Contract interaction | Ethers.js | Handles reads, writes, events, and signers |
| SEO-friendly frontend | Next.js | Supports SSR, routing, and app growth |
| Frontend deployment | Vercel | Speeds up shipping and preview workflows |
| Product analytics | PostHog | Tracks user behavior outside on-chain activity |
Best Moralis Tool Stack by Scenario
For an NFT marketplace
- Moralis for NFT data and wallet auth
- WalletConnect for wallet onboarding
- IPFS for metadata and media
- Next.js for frontend delivery
- Vercel for deployment
This stack works well when speed matters and the team wants a standard architecture. It breaks when marketplace logic becomes highly custom and needs deep indexing beyond standard API patterns.
For a DeFi dashboard
- Moralis for broad wallet and token data
- The Graph for protocol-specific indexed views
- Alchemy for RPC and simulations
- Ethers.js for transaction flows
This works when the app needs both prebuilt API speed and custom protocol data. It becomes harder to manage if the data model is split across too many providers without clear ownership.
For a Web3 SaaS product
- Moralis for auth and blockchain data abstraction
- Next.js for app and marketing site
- Vercel for fast deployment
- PostHog for funnel and user analytics
This is strong for startups selling dashboards, alerts, compliance tools, or wallet intelligence products. It fails when teams ignore backend job architecture and rely only on frontend polling.
Workflow: How These Tools Work Together With Moralis
- User connects a wallet through WalletConnect or another provider.
- Moralis handles authentication and retrieves wallet-related data.
- Ethers.js manages direct contract interactions when the user signs or sends transactions.
- IPFS stores NFT metadata or user-generated decentralized content.
- The Graph or Alchemy handles custom index or infrastructure-heavy needs.
- Next.js renders the frontend experience.
- Vercel deploys the app.
- PostHog tracks onboarding, activation, and retention events.
Comparison Table: Which Tool Should You Add First?
| Tool | Main Role | Best For | Main Limitation |
|---|---|---|---|
| WalletConnect | Wallet connectivity | Consumer-facing dApps | More wallet UX edge cases |
| IPFS | Decentralized storage | NFTs and media apps | Needs pinning strategy |
| Alchemy | RPC infrastructure | DeFi and transaction-heavy apps | Can overlap with Moralis features |
| Infura | Ethereum RPC and IPFS | Ethereum-first teams | Less abstracted product features |
| The Graph | Custom indexing | Protocol analytics | Maintenance overhead |
| OpenZeppelin | Contract security | Any app deploying contracts | Does not replace audit discipline |
| Ethers.js | Contract interaction | Transaction logic | Lower-level developer work |
| Next.js | Frontend framework | SEO and app UX | Rendering complexity |
| Vercel | Deployment | Fast-moving startups | Not a full backend ops layer |
| PostHog | Product analytics | Growth optimization | Needs strong event design |
Expert Insight: Ali Hajimohamadi
Most founders over-stack too early. They add Moralis, The Graph, Alchemy, custom indexers, and analytics before they even know which query pattern drives revenue.
A better rule is this: choose one system for default data access and one system for edge-case depth. Not three.
In early-stage Web3 products, complexity usually kills shipping speed before infrastructure limits kill performance.
Moralis works best when you let it cover 80% of data needs, then add a second tool only where your product has a proven bottleneck.
If every endpoint in your app comes from a different provider, your team is not building leverage. It is building future debugging debt.
How to Choose the Right Tool With Moralis
- Choose WalletConnect if your biggest problem is wallet onboarding.
- Choose IPFS if your product stores NFT metadata or decentralized files.
- Choose Alchemy or Infura if you need direct RPC-level control.
- Choose The Graph if your product depends on custom event-derived data models.
- Choose OpenZeppelin if you deploy smart contracts and need safer defaults.
- Choose PostHog if your problem is conversion, retention, or drop-off analysis.
The right choice depends on where your product is weak today. If your bottleneck is user activation, adding more blockchain infrastructure will not help. If your bottleneck is protocol-specific analytics, frontend tooling will not fix it.
FAQ
Is Moralis enough on its own for most Web3 apps?
For MVPs, often yes. Moralis can cover auth, wallet data, NFT data, and multi-chain API needs. But most production apps still need at least one extra tool for storage, contract interaction, deployment, or analytics.
What is the best wallet tool to use with Moralis?
WalletConnect is one of the best options, especially for mobile users and broad wallet compatibility. It is a strong addition when user onboarding matters more than developer convenience alone.
Should I use Moralis with The Graph?
Yes, if your app needs custom indexed views that Moralis does not expose in a clean way. No, if your team does not have the bandwidth to maintain subgraphs or if standard APIs already solve the use case.
What storage tool works best with Moralis for NFTs?
IPFS is the most common answer for NFT metadata and media. It works best when paired with a clear pinning and delivery strategy.
Do I still need Ethers.js if I use Moralis?
Usually yes. Moralis helps with indexed and abstracted blockchain data, while Ethers.js helps with direct contract reads, writes, and signer-driven transactions.
What is the best frontend stack for Moralis?
Next.js and Vercel are a practical combination for many startups. This setup is especially effective for products that need both application logic and search-friendly landing pages.
What is the biggest mistake when combining tools with Moralis?
The biggest mistake is adding too many overlapping providers too early. This creates fragmented data ownership, higher costs, and debugging problems that small teams struggle to manage.
Final Summary
The best tools to use with Moralis depend on what your product actually needs.
- Use WalletConnect for better wallet onboarding.
- Use IPFS for NFT metadata and decentralized files.
- Use Alchemy or Infura for direct infrastructure access.
- Use The Graph for custom indexing.
- Use OpenZeppelin for contract safety.
- Use Ethers.js for direct smart contract interaction.
- Use Next.js and Vercel for frontend delivery.
- Use PostHog for product analytics.
The strongest Moralis stack is usually not the biggest one. It is the one with the fewest moving parts needed to ship reliably, learn fast, and scale without architectural confusion.
