What LPSignal does

LPSignal watches concentrated-liquidity pools on Ethereum, BNB Chain, Base, Arbitrum, Optimism and Polygon (Uniswap v3 and v4, PancakeSwap v3, Aerodrome and Velodrome Slipstream). Every hour it measures what a liquidity position would have earned in each pool, after impermanent loss, for a set of price ranges. When a range has been paying well for a week and is still paying today, you get a signal with the exact position to open.

Both tokens in a pool must be on our blue-chip list, so you won't see signals for new or illiquid tokens. Uniswap v4 pools are covered only when they have no hooks and a fixed fee.

How net APR is measured

Net APR = fee APR − impermanent loss, annualised from a backtest over the pool's own hourly history. (The API reports the loss as a negative ilApr, so there netApr = feeApr + ilApr.)

• Fees come from the pool contract's fee-growth counters, read at the end of every hour. This is the exact amount a unit of in-range liquidity earned, including dynamic fees. We never estimate fees from trading volume for a signal.
• Impermanent loss is the position's value compared with simply holding the two tokens you deposited, marked at each hour's closing price.
• In range is the share of hours the price spent inside the range. Out-of-range hours earn nothing and still count in the average.

Each pool is tested on range widths that suit its type. A range of ±5% means the position covers prices from 5% below to 5% above the price at entry, rounded outwards to the pool's tick spacing.

Windows are the last 24 hours, 7 days and 30 days. Aerodrome and Velodrome figures are for unstaked liquidity. Where staking in the gauge pays emissions, we show that rate next to the pool for reference, but it never triggers a signal and is not backtested.

When a signal fires

A pool fires an opportunity signal when one of its ranges meets all of these at the top of an hour:

• Only exact fee data counts. If fee-growth readings are missing for a window, the pool can't fire.
• If more than one range qualifies, you get the one with the highest 7-day net APR.
• After a signal, the same pool stays quiet for 72 hours unless its 7-day net APR climbs to 1.5 times what it was at the last signal.
• A chain that is more than 2 hours behind fires nothing until it catches up, so you never get a signal about stale data.

Short-term opportunities

Some ranges pay very well for an hour or a few — a volatile session, a new incentive, a burst of flow — long before a 7-day average notices. A short-term signal (kind: "burst") fires when a range meets all of these at the top of an hour:

• Only exact fee data counts, like every opportunity.
• A pool that fired a 7-day signal in the same hour does not also get a short-term one. After a short-term signal the pool stays quiet for 12 hours unless its one-hour net APR grows by half again.
• Each short-term signal is scored on the 24 hours after it fires (7-day signals on the 7 days after), in its own track record: GET /v1/signals/stats?kind=burst.
• Signals arrive 30–90 minutes after the hour they describe (the archive only carries finalized blocks). A one-hour burst can be over by the time you act. The shortest window is one hour because the data is hourly.

High yield, high risk

DEX sites rank pools by their pool-level APR: the last 24 hours of swap fees divided by the pool's liquidity, annualised. A high-yield signal (kind: "hot_pool") fires when a big pool's figure jumps, once all of these hold at the top of an hour:

• Fees are estimated as volume × the pool's fee rate, valued at the latest prices. Uniswap v4 pools are left out: their TVL is the depth near the price, which would overstate the figure.
• It is a pool-level figure, not a recommended position (tickLower and tickUpper are 0), and it is not scored. Next to it, bestNet24h is what our best range actually netted over the same day after impermanent loss (bestRangeBp says which), or null without a 24-hour backtest.
• One per pool per 24 hours. Paid plans get it live, the free plan 24 hours later, like the other opportunities.

Track record

Seven days after an opportunity signal fires, we backtest the exact ticks it recommended over those seven days and publish the result on the signal. This happens for every signal, including the losing ones.

• Result: the realised net APR, with its fee and IL parts.
• Pending: fewer than 7 days have passed.
• Unscored: exact fee data for that week never arrived. These are shown but left out of the averages, so the track record is never padded with estimates.

Risk alerts

Risk alerts are free and live on every plan.

Smart LP scoring

We follow position NFTs on Uniswap v3, PancakeSwap v3 and Slipstream from deposit to final withdrawal. When a position closes, its score is what the owner collected minus what holding the deposited tokens would be worth, valued at the pool's price at the moment of that withdrawal.

• A wallet needs at least 3 scored closes and $10,000 of capital to be ranked.
• Positions funded by more than one wallet, moved to a new owner mid-life, staked in a gauge, or first seen after they opened are not scored.
• Bots and vaults are not ranked: contract addresses, wallets that close more than 10 positions a day, and wallets whose positions last under an hour at the median. A signal reaches you minutes to an hour after the opening, too late to follow them. Wallets you follow are still reported.
• Pro members get an alert when a top-20 wallet, or one they follow, opens a position of $10,000 or more.

Plans and delays

Plan limits are checked again when each message is sent, so a signal queued before a plan lapses isn't delivered after it.

Custom rules

On Basic (3 rules) and Pro (20 rules) you can set your own thresholds. Every rule is checked each hour on the same exact data as the default signals. A match is sent only to you, on every channel you connected; it carries a rule field with the rule's id and name, and it is not scored or shown in the public track record.

Narrow any rule with chains, pairClasses, pools ("chain:address", up to 50) and minTvlUsd (at least 100,000; default 1,000,000). cooldownHours (24–720, default 24) keeps a rule quiet on the same pool after it fires. An account gets at most 50 matches per 24 hours.

Rule matches arrive whatever your subscriptions are (turn off the kinds you only want through your rules). A match that repeats a signal you already receive for the same pool and hour is skipped. After a downgrade your rules are kept, but only as many as the plan allows run (active).

What is pushed to you

Telegram, webhooks and the WebSocket stream carry the kinds of signal you subscribe to. The core events are on by default: net_apr, tvl_outflow, depeg and smart_lp. Short-term burst and high-yield hot_pool signals are pushed only after you add them. Your plan still decides what you may receive, and matches of your custom rules always arrive.

Change it on your account page or with PUT /v1/me/subscriptions and {"kinds": ["net_apr", "burst", "depeg"]}. A WebSocket connection can pick its own kinds with ?kinds=net_apr,burst, and REST takes the same kinds parameter; source=subscribed returns exactly what your push channels deliver.

SDKs

Official SDKs for Node.js (20+) and Python (3.10+) wrap the whole API, the signal stream and webhook verification. They are open source under the MIT license: LPSignals/lpsignal-node and LPSignals/lpsignal-python.

npm install lpsignal

pip install lpsignal

• REST client with typed responses, API error codes as exceptions, and automatic retry after a rate-limit response.
• A stream that never misses a signal. Before every connection the SDK fetches anything newer than your last signal over REST, then resumes the stream after it. Outages of any length are filled, and while your process runs each signal reaches you once. After a crash the last one may come again, so handle signals idempotently by id.
• Resume after restarts. Save the last signal id with the built-in file store; Node and Python use the same file format.
• Webhook verification in one call, returning the parsed delivery.

Authentication

The REST API lives at https://api.lpsignal.app/v1. Public endpoints work without a key. Send your key as a bearer token to get your plan's view of signals and to use account endpoints. Keys start with lps_. Create or replace one from Account.

import { LPSignal } from 'lpsignal';

const lps = new LPSignal({ apiKey: process.env.LPSIGNAL_API_KEY });
const { signals, next } = await lps.signals({ kind: 'net_apr', limit: 20 });
// next page: lps.signals({ kind: 'net_apr', before: next })

import os
from lpsignal import LPSignal

lps = LPSignal(api_key=os.environ["LPSIGNAL_API_KEY"])
page = lps.signals(kind="net_apr", limit=20)
# next page: lps.signals(kind="net_apr", before=page["next"])

curl "https://api.lpsignal.app/v1/signals?kind=net_apr&limit=20" \
  -H "Authorization: Bearer lps_live_..."

Anonymous and free callers see opportunity signals once they are 24 hours old. Risk alerts are always included.

Rate limits and errors

Over a limit you get 429 with a Retry-After header. Errors are JSON with a stable error code:

Endpoints

All APR and ratio fields are fractions: 0.345 means 34.5%. fee is in hundredths of a basis point, so 500 is a 0.05% fee tier. Timestamps are ISO 8601 in UTC. Ids are strings.

Signal object

REST, webhooks and the stream all send signals in this shape.

{
  "id": "4821",
  "kind": "net_apr",
  "firedAt": "2026-09-30T09:00:00.000Z",
  "chain": "base",
  "dex": "uniswap_v3",
  "pool": "0xd0b53d9277642d899df5c87a3966a349a798f224",
  "pair": "WETH/USDC",
  "fee": 500,
  "pairClass": "volatile",
  "tvlUsd": 38200000,
  "rangeBp": 500,
  "entryTick": -200720,
  "tickLower": -201210,
  "tickUpper": -200230,
  "net24h": 0.41,
  "net7d": 0.345,
  "net30d": 0.298,
  "fee7d": 0.518,
  "il7d": -0.173,
  "inRange7d": 0.94,
  "rule": null,
  "outcome": null
}

Risk alerts carry drop, tvlBeforeUsd, tvlNowUsd and windowHours (outflow) or deviation and severe (depeg). Smart LP alerts carry owner, rank, top, entryUsd and wallet30d. High-yield signals carry poolApr24h, poolApr7d, volume24hUsd, fees24hUsd, bestNet24h, bestRangeBp and risk.

Webhooks

Each signal is POSTed to your URL as {"type": "signal", "deliveryId": "…", "signal": {…}} with these headers:

import express from 'express';
import { verifyWebhook, WebhookVerificationError } from 'lpsignal';

app.post('/lpsignal', express.raw({ type: 'application/json' }), (req, res) => {
  try {
    const event = verifyWebhook(req.body, req.headers, process.env.LPSIGNAL_WEBHOOK_SECRET);
    // at-least-once: skip event.deliveryId if you have already handled it
    res.sendStatus(200);
  } catch (e) {
    if (e instanceof WebhookVerificationError) return res.status(400).send(e.reason);
    throw e;
  }
});

from fastapi import FastAPI, Request, Response
from lpsignal import WebhookVerificationError, verify_webhook

app = FastAPI()

@app.post("/lpsignal")
async def lpsignal(request: Request):
    try:
        event = verify_webhook(await request.body(), request.headers, SECRET)
    except WebhookVerificationError as e:
        return Response(e.reason, status_code=400)
    # at-least-once: skip event["deliveryId"] if you have already handled it
    return Response(status_code=200)

import crypto from 'node:crypto';

// without the SDK: use the raw request body, re-serialised JSON will not match
function verify(rawBody, headers, secret) {
  const ts = headers['x-lpsignal-timestamp'];
  if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;   // replay window
  const want = 'sha256=' + crypto.createHmac('sha256', secret).update(`${ts}.`).update(rawBody).digest('hex');
  const got = headers['x-lpsignal-signature'] ?? '';
  return got.length === want.length && crypto.timingSafeEqual(Buffer.from(got), Buffer.from(want));
}

• Respond with any 2xx within 15 seconds. Redirects are not followed.
• Failed deliveries are retried after 1 minute, 5 minutes, 30 minutes and 2 hours, then dropped.
• The URL must be HTTPS and resolve to a public address. It is checked again on every delivery.

WebSocket stream

The SDKs handle everything below for you, including catching up after outages longer than 24 hours. Connect to wss://api.lpsignal.app/v1/stream with your key in the Authorization header, or as ?key= from a browser. Signals arrive in ascending id order and never twice on one connection. Save the last id you processed and reconnect with ?since=<id> to catch up on anything from the last 24 hours. Add ?kinds=net_apr,burst to choose the kinds for one connection; without it you get the kinds you subscribe to.

import { LPSignal, SignalStream, FileLastIdStore } from 'lpsignal';

const stream = new SignalStream({
  client: new LPSignal({ apiKey: process.env.LPSIGNAL_API_KEY }),
  store: new FileLastIdStore('./lpsignal-state.json'),   // resume point survives restarts
  onSignal: async (signal, { source }) => {
    // once per signal, in id order; source = 'rest' | 'replay' | 'live'
  },
  onEvent: (e) => { if (e.type === 'fatal') console.error(e.error.message); },
});
await stream.start();

import asyncio, os
from lpsignal import AsyncLPSignal, FileLastIdStore, SignalStream

async def on_signal(signal, source):   # "rest" | "replay" | "live"
    ...

async def main():
    lps = AsyncLPSignal(api_key=os.environ["LPSIGNAL_API_KEY"])
    await SignalStream(lps, on_signal, store=FileLastIdStore("lpsignal-state.json")).run()

asyncio.run(main())

The server pings every 30 seconds; standard clients answer automatically.

Telegram

1. In Account, choose Connect Telegram to get a one-time code.
2. Open @LPsignals_bot and send /start <code>.
3. Signals your plan includes now arrive in that chat. Free plans get opportunity signals 24 hours after they fire.