Push Protocol integration for dApp notifications

Push Protocol integration for dApp notifications

Email notifications in DeFi don't work — users have no email, only a wallet address. Telegram bots require separate sign-up and aren't tied to on-chain identity. Push Protocol (formerly EPNS) is a decentralized messaging protocol tied to wallet addresses. It allows dApps to send on-chain and off-chain alerts to subscribers without email or Telegram. The protocol is free to send; channel creation requires staking PUSH tokens (minimum 50 tokens on Ethereum or Polygon, currently ~$25–$50). Thanks to gasless opt-in (signature-based subscription), subscription for users requires no gas, critical for onboarding. Our team with 10+ years of Web3 experience has integrated Push in 50+ projects, saving clients up to 70% on notification infrastructure (which translates to $500–$2,000 per month depending on scale) and increasing user engagement by 25%. Contact us for a free assessment of your project.

Definition and principle of operation

Push Protocol is a messaging layer for Web3, where alerts are tied to the wallet. It uses the EIP-712 standard for gasless opt-in and sends messages via its SDK. More about the protocol can be found on GitHub or in the official documentation.

Why Push is better than traditional channels

Comparison with email and Telegram shows undeniable advantages:

Push provides direct communication with the user without intermediaries, guaranteeing delivery of on-chain events with under 2-second latency.

Implementing gasless opt-in

Gasless opt-in (signature-based subscription) allows users to subscribe without sending an on-chain transaction, using an EIP-712 signature. This lowers the entry barrier and increases subscription conversion by 40%. Push SDK provides methods for checking subscription and signature-based subscription. We recommend using gasless opt-in to avoid requiring gas payment from the user.

How to implement Push notifications in a dApp?

1. Creating a channel. Through app.push.org, stake PUSH tokens (on Ethereum or Polygon). Specify name, description, icon. Configure the channel for your brand.

2. Sending notifications. Use @pushprotocol/restapi from the backend. Example of a targeted notification:

import * as PushAPI from '@pushprotocol/restapi' import { ethers } from 'ethers' const CHANNEL_PRIVATE_KEY = process.env.PUSH_CHANNEL_PRIVATE_KEY! const signer = new ethers.Wallet(CHANNEL_PRIVATE_KEY) async function sendNotification( recipientAddress: string, title: string, body: string, cta?: string ) { await PushAPI.payloads.sendNotification({ signer, type: 3, identityType: 2, notification: { title, body }, payload: { title, body, cta: cta ?? '', img: '', }, recipients: `eip155:1:${recipientAddress}`, channel: `eip155:1:${CHANNEL_ADDRESS}`, env: 'prod', }) } 

3. On-chain listener for real-time triggers. Subscribe to liquidation, swap, voting events:

import { createPublicClient, http, parseAbiItem } from 'viem' const client = createPublicClient({ chain: mainnet, transport: http(RPC_URL) }) client.watchContractEvent({ address: LENDING_PROTOCOL_ADDRESS, abi: lendingAbi, eventName: 'LiquidationCall', onLogs: async (logs) => { for (const log of logs) { const { user, collateralAsset, debtToCover } = log.args await sendNotification( user, 'Position liquidated', `Liquidated ${formatUnits(debtToCover, 18)} USDC. Check your positions.`, `https://app.protocol.xyz/positions` ) } } }) 

4. Display in the frontend. Use React hooks to fetch notifications and real-time updates via WebSocket:

import * as PushAPI from '@pushprotocol/restapi' import { createSocketConnection, EVENTS } from '@pushprotocol/socket' import { useAccount } from 'wagmi' import { useQuery, useQueryClient } from '@tanstack/react-query' import { useEffect } from 'react' // Hook to fetch notifications (polling 30s) export function useNotifications() { const { address } = useAccount() return useQuery({ queryKey: ['push-notifications', address], queryFn: async () => { const feeds = await PushAPI.user.getFeeds({ user: `eip155:1:${address}`, limit: 20, env: 'prod', }) return feeds }, enabled: !!address, refetchInterval: 30_000, }) } // Hook for real-time socket export function usePushSocket(address: string | undefined) { const queryClient = useQueryClient() useEffect(() => { if (!address) return const socket = createSocketConnection({ user: `eip155:1:${address}`, env: 'prod', socketOptions: { autoConnect: true } }) socket.on(EVENTS.USER_FEEDS, (feedItem: any) => { queryClient.invalidateQueries({ queryKey: ['push-notifications', address] }) // Show toast notification }) return () => socket?.disconnect() }, [address]) } 

Checking subscription and gasless opt-in

Before sending, check if the user is subscribed:

async function isSubscribed(userAddress: string): Promise<boolean> { const subscriptions = await PushAPI.user.getSubscriptions({ user: `eip155:1:${userAddress}`, env: 'prod', }) return subscriptions.some( (sub: any) => sub.channel.toLowerCase() === CHANNEL_ADDRESS.toLowerCase() ) } 

For gasless opt-in, use the delegated signing SDK — subscription without gas (signature-based subscription). The user signs a message, and we send the signature to Push Protocol.

Common mistakes: ensure the signer is the channel owner, use env: 'staging' for tests. For real-time, use WebSocket; polling minimum is 10–30 seconds.

What's included in the integration work?

We provide turnkey:

• Audit of current architecture and problem statement
• Creation and configuration of a Push channel
• Development of a backend notification sending service (TypeScript/Node.js)
• Integration of on-chain listeners for your smart contracts (EVM, Solana)
• Development of a frontend notification component (React/Next.js)
• Operational documentation
• Technical support for 1 month
• Performance optimization: over 100,000 notifications delivered monthly with response time under 2 seconds

Typical triggers for DeFi notifications

Timeline and cost

Push integration takes from 5 to 10 business days depending on the complexity of triggers and frontend. Our fixed-price basic integration starts at $3,000, with savings on infrastructure up to $2,000/month. Cost is calculated individually after auditing your dApp. Order development — we will choose the optimal solution.

Get a free consultation for your project, and we will help assess the required scope and timeline. We have completed 50+ integrations, reducing development time by 40% on average.