Delta-Neutral Points Farming: Farm Perp DEX Airdrops Without Betting on Price (Python Bot)

New perpetual-futures exchanges (perp DEXs) all have the same problem: nobody trades on an empty order book. Their fix is a points program. Trade volume, keep open interest, provide liquidity, and you collect points. Later the project launches a token and converts points into it.

The one everybody remembers is Hyperliquid. In November 2024 it airdropped 31% of the HYPE supply to roughly 94,000 addresses, based on points earned by trading. HYPE started trading around $3–4 and was above $30 within about three weeks. Active traders who had farmed points that year ended up with allocations that were, at those prices, often worth thousands to tens of thousands of dollars. That is the outlier everyone chases; most points programs since have paid far less.

The catch for most people: to earn points you have to trade, and trading means price risk. Farm with a naked long and a 15% dump erases a year of airdrop.

Delta-neutral farming removes the price bet. You open a long on the venue that pays points and an equal short on a big, cheap, liquid exchange (Binance, Bybit, OKX). Price goes up, the long gains what the short loses. Price goes down, the reverse. What you are left with is a known cost (fees, funding difference, slippage) in exchange for an unknown but potentially large payout (the airdrop).

This guide gives you the math, a Python bot built on ccxt that opens and closes hedged pairs and logs your real cost per $1M of farmed volume, and the honest part: capital needs, the scenario where you lose money, and why points programs are getting better at filtering farmers.

Who this works for (read first)

• Crypto derivatives are restricted in a lot of places. The UK’s FCA has banned the sale of crypto derivatives to retail consumers since January 2021. Binance.com and Bybit do not serve US residents, and many perp DEXs list the US (and often Ontario, sanctioned countries and others) as restricted in their terms. Read the terms of both venues for your country.
• Do not VPN around a geoblock. It breaks the terms, and the usual outcome is that the frontend locks your account to close-only or the CEX freezes withdrawals pending “additional verification”. On a hedged position, one frozen leg means you are suddenly unhedged.
• Indonesia: crypto supervision moved from Bappebti to OJK in January 2025. Offshore exchanges without a local license can be blocked by Komdigi at any time, and crypto gains are taxable. Check the current OJK list and tax rules before you size anything.
• Taxes everywhere: every open and close is a taxable event in many countries, and the airdrop itself is usually taxed as income at the value when you receive it. The bot’s CSV log is your tax record.

How the money works

Example with $20,000 of capital:

• $10,000 USDC on the farm venue (the perp DEX with points), 3x leverage, long $30,000 of ETH.
• $10,000 USDT on the hedge venue (Binance USDⓈ-M futures), 3x leverage, short $30,000 of ETH.

Net exposure: zero. Each day the bot closes both legs and reopens them. One cycle is two trades per leg, so $60,000 of volume on each venue per day, or about $1.8M of farmed volume per month.

What it costs

Base-tier fees (check each venue’s current fee page, tiers change):

Note: Hyperliquid’s own points program ended with the November 2024 airdrop, and as of October 2026 no new season has been announced. This guide uses it only because its fees and ccxt integration are well documented. Swap in whichever perp DEX is running a live, pre-token points program when you read this, and use its fee schedule.

Monthly cost for $1.8M on each side:

• Lazy version (taker on both legs): $1.8M × 0.045% + $1.8M × 0.05% = $810 + $900 = $1,710/month
• Bot version (maker on farm leg, taker on hedge): $1.8M × 0.015% + $900 = $270 + $900 = $1,170/month
• Plus slippage: on ETH or BTC at these sizes, a few dollars per cycle on the hedge. On thin alt markets it can be more than the fee itself.

Funding

Both legs pay or receive funding. You are long on one and short on the other, so you pay one and collect the other. When the two rates are similar, it nets close to zero. Hyperliquid pays funding every hour with a baseline interest component of 0.01% per 8 hours; Binance charges most perps every 8 hours with the same 0.01% default interest. When the farm venue’s longs get crowded, its funding spikes and you bleed. That is why the bot checks the funding difference before opening, and why you can flip the direction (short on the farm venue, long on the hedge) when funding favors it. Points programs usually do not care which direction you trade.

What it pays

Nobody knows until the token launches. That is the honest answer. Your decision is: is $1,170 a month for $1.8M of volume a good price for whatever those points will be worth?

Those rows are scenarios, not promises. Plenty of 2024–2025 points programs ended in disappointing airdrops; Blast’s June 2024 drop is the classic example people point to of points that felt worth far more than they paid. The play only works as a portfolio: farm two or three venues at once, cut the ones whose points economy looks diluted, and accept that some will lose money.

Do not think of this as monthly income. Even with $50k–$100k spread across several venues, the cash flow is negative most of the time: you pay fees every month, then get one payout (large, small or close to zero) at each token launch.

What you need

ccxt is a free, open-source library with a unified API for 100+ exchanges. Check that both your venues are supported:

python3 -c "import ccxt; print([e for e in ccxt.exchanges if e in (\"hyperliquid\",\"binanceusdm\",\"bybit\",\"okx\",\"paradex\")])"

Step 1: Pick the farm venue

Before you deposit anything, answer four questions about the points program:

1. Is there a token yet? If yes, you are farming “season 2”, which usually pays less. Pre-token programs carry the biggest upside and the biggest uncertainty.
2. What earns points? Volume only, or also open interest, maker liquidity, holding time, PnL? If holding time counts, you can rotate less often and pay far fewer fees.
3. Are points published weekly? You need to see your points per week to compute your cost per point. No visibility, no farming.
4. Who is backing it, and does it hold real user deposits? A perp DEX can get exploited or rugged. Your farm-leg collateral is at risk the whole time.

Then cross-check on the project’s docs, its Discord and a community points-price market if one exists (some pre-market venues trade points or pre-launch tokens). A pre-market price is the closest thing to a real valuation you will get.

Step 2: Configure the bot

Save as config.py. Use environment variables for secrets, never hard-code them.

import os

FARM = {
    "id": "hyperliquid",          # any ccxt id
    "symbol": "ETH/USDC:USDC",
    "maker_fee": 0.00015,
    "taker_fee": 0.00045,
    "funding_hours": 1,
    "creds": {
        "walletAddress": os.environ["FARM_WALLET"],
        "privateKey": os.environ["FARM_API_KEY"],   # API wallet key, not your main key
    },
}

HEDGE = {
    "id": "binanceusdm",
    "symbol": "ETH/USDT:USDT",
    "maker_fee": 0.0002,
    "taker_fee": 0.0005,
    "funding_hours": 8,
    "creds": {
        "apiKey": os.environ["HEDGE_KEY"],
        "secret": os.environ["HEDGE_SECRET"],
    },
}

NOTIONAL_USD = 30000        # per leg
FARM_SIDE = "buy"           # "buy" = long on farm venue, short on hedge
MAX_FUNDING_DIFF_APR = 0.15 # skip if paying more than 15% APR net funding
FILL_TIMEOUT_S = 120        # how long to wait for the maker order
LOG_FILE = "farm_log.csv"

Step 3: The hedged-pair bot

The logic: post a maker order on the farm venue (cheaper, and some programs weight maker volume higher), wait for it to fill, then immediately hedge the filled amount with a market order on the hedge venue. Unfilled after the timeout? Cancel and hedge whatever did fill. Never leave a leg naked.

Save as farm.py:

import csv, random, sys, time
from datetime import datetime, timezone
import ccxt
from config import *

def connect(cfg):
    ex = getattr(ccxt, cfg["id"])({**cfg["creds"], "enableRateLimit": True})
    ex.load_markets()
    return ex

farm, hedge = connect(FARM), connect(HEDGE)
opp = {"buy": "sell", "sell": "buy"}

def mid(ex, symbol):
    ob = ex.fetch_order_book(symbol, 5)
    return (ob["bids"][0][0] + ob["asks"][0][0]) / 2, ob

def funding_apr(ex, cfg):
    rate = ex.fetch_funding_rate(cfg["symbol"])["fundingRate"] or 0
    return rate * (24 / cfg["funding_hours"]) * 365

def net_funding_apr(farm_side):
    f, h = funding_apr(farm, FARM), funding_apr(hedge, HEDGE)
    # positive rate: longs pay shorts. Return what WE pay per year (negative = we earn)
    return (f - h) if farm_side == "buy" else (h - f)

def log(action, side, amount, price_f, price_h, fee_usd):
    with open(LOG_FILE, "a", newline="") as fh:
        csv.writer(fh).writerow([datetime.now(timezone.utc).isoformat(), action,
                                 side, amount, price_f, price_h, round(fee_usd, 4),
                                 round(amount * price_f, 2)])

def maker_then_hedge(side, amount, reduce_only=False):
    price, ob = mid(farm, FARM["symbol"])
    # post at the best price on our side of the book so we stay maker
    limit = ob["bids"][0][0] if side == "buy" else ob["asks"][0][0]
    params = {"postOnly": True, "reduceOnly": reduce_only}
    o = farm.create_order(FARM["symbol"], "limit", side,
                          farm.amount_to_precision(FARM["symbol"], amount),
                          farm.price_to_precision(FARM["symbol"], limit), params)
    deadline = time.time() + FILL_TIMEOUT_S
    while time.time() < deadline:
        o = farm.fetch_order(o["id"], FARM["symbol"])
        if o["status"] == "closed":
            break
        time.sleep(3)
    if o["status"] != "closed":
        try:
            farm.cancel_order(o["id"], FARM["symbol"])
        except ccxt.OrderNotFound:
            pass  # filled in the meantime
        o = farm.fetch_order(o["id"], FARM["symbol"])
    filled = float(o["filled"] or 0)
    if filled == 0:
        print("no fill, nothing to hedge")
        return 0
    hp, _ = mid(hedge, HEDGE["symbol"])
    hedge.create_order(HEDGE["symbol"], "market", opp[side],
                       hedge.amount_to_precision(HEDGE["symbol"], filled),
                       None, {"reduceOnly": reduce_only})
    fee = filled * limit * FARM["maker_fee"] + filled * hp * HEDGE["taker_fee"]
    log("close" if reduce_only else "open", side, filled, limit, hp, fee)
    print(f"{side} {filled} on farm @ {limit}, hedged @ ~{hp}, est fee ${fee:.2f}")
    return filled

def check_delta(tolerance=0.02):
    pf = farm.fetch_positions([FARM["symbol"]])
    ph = hedge.fetch_positions([HEDGE["symbol"]])
    size = lambda ps: sum(float(p["contracts"] or 0) * float(p.get("contractSize") or 1)
                          * (1 if p["side"] == "long" else -1) for p in ps)
    net = size(pf) + size(ph)
    gross = max(abs(size(pf)), 1e-9)
    if abs(net) / gross > tolerance:
        print(f"DELTA MISMATCH: farm {size(pf)}, hedge {size(ph)}. Fix manually.")
        sys.exit(1)
    return size(pf)

if __name__ == "__main__":
    cmd = sys.argv[1] if len(sys.argv) > 1 else "status"
    if cmd == "open":
        apr = net_funding_apr(FARM_SIDE)
        print(f"net funding we pay: {apr:.2%} APR")
        if apr > MAX_FUNDING_DIFF_APR:
            sys.exit("funding too expensive, flip FARM_SIDE or wait")
        price, _ = mid(farm, FARM["symbol"])
        size_usd = NOTIONAL_USD * random.uniform(0.8, 1.2)  # vary size ±20%
        maker_then_hedge(FARM_SIDE, size_usd / price)
    elif cmd == "close":
        pos = check_delta()
        if pos:
            maker_then_hedge("sell" if pos > 0 else "buy", abs(pos), reduce_only=True)
    check_delta()

Test with tiny size first. Set NOTIONAL_USD = 50, run:

python3 farm.py open
python3 farm.py status
python3 farm.py close

Check both exchange UIs after each step. Position sizes should match, and farm_log.csv should have two rows.

Two venue-specific notes. Hyperliquid in ccxt needs a price even for market orders (it uses it to cap slippage), so if Hyperliquid is your hedge leg, pass hp as the price. And Binance needs “One-way mode” for reduceOnly to behave as written; in hedge mode you would pass positionSide instead.

Step 4: Rotate on a schedule

Cron does not load your shell profile, so the os.environ[...] lookups in config.py would fail. Put the secrets in a file only you can read, /home/you/farm/.env:

export FARM_WALLET=0x...
export FARM_API_KEY=0x...
export HEDGE_KEY=...
export HEDGE_SECRET=...

Run chmod 600 /home/you/farm/.env, then add one daily cron job. It waits a random delay of up to 3 hours, closes, waits 10 minutes and reopens. $RANDOM needs bash, so the job runs through bash -c:

crontab -e
5 0 * * * /bin/bash -c 'sleep $((RANDOM \% 10800)); cd /home/you/farm && . ./.env && python3 farm.py close && sleep 600 && python3 farm.py open' >> /home/you/farm/bot.log 2>&1

(In crontab, % must be escaped as \%.) The && chain only reopens if the close succeeded and the delta check passed.

Why randomize? A wallet that closes and reopens exactly $30,000 at exactly 00:05 every day looks exactly like a bot, because it is one. The bot already varies size by ±20%, and the sleep varies timing. This is also just better execution: you avoid the moments everyone else’s cron fires.

Step 5: Track cost per point

Every week, when the venue publishes points, add them to a sheet and compute:

python3 -c "
import csv
rows = list(csv.reader(open(\"farm_log.csv\")))
fees = sum(float(r[6]) for r in rows)
vol = sum(float(r[7]) for r in rows)
print(f\"farm volume ${vol:,.0f}  fees ${fees:,.2f}  cost per 1M ${fees / vol * 1e6:,.0f}\")
"

Divide total cost (fees + net funding + slippage) by points earned. That cost per point is the only number that matters. When a pre-market or OTC price for points shows up, compare. If you are paying $0.40 a point and the market prices them at $0.15, stop.

Risks (read this twice)

Liquidation on one leg. Delta-neutral does not mean liquidation-proof. If ETH pumps 30%, your short is deep in loss on the hedge venue while the profit sits on the farm venue. You cannot move margin instantly between them. Keep leverage at 2–3x, set price alerts, and keep spare USDT on the hedge venue to top up. At 10x, a fast wick will liquidate one leg and leave the other naked.

Points get filtered or diluted. Projects run anti-farming analysis before the airdrop. Self-trading (matching your own orders within one venue), wash patterns between your own wallets and identical behavior across many wallets get excluded. LayerZero is the cautionary tale: before its June 2024 airdrop it flagged roughly 800,000 addresses as sybil. Cross-venue hedging from one wallet is ordinary trading on the farm venue, which is why it survives filters far better than multi-wallet farming. Projects can still change the rules after the fact and weight things you did not optimize for.

Venue risk. A new perp DEX holds your collateral in smart contracts, often with young code. Exploits happen, and so do oracle manipulation incidents and bad-debt events that socialize losses to users. Never put more on the farm venue than you could lose outright.

Account risk on the CEX. Binance and Bybit can freeze withdrawals for compliance review, especially when funds move back and forth to DeFi a lot. Keep KYC clean and your country of residence honest.

Funding regime change. In hot markets, funding on new venues can run 50–100%+ APR for a side. The bot’s funding check stops new positions, but an open position can bleed for days before rotation. Watch it.

Reality check: what does NOT work

• Farming with 20 wallets. This used to be the meta. Now it is how you get your whole cluster zeroed. Funding patterns, identical trade sizes and timing make wallets easy to link. One well-funded real wallet beats twenty thin ones.
• Self-trading for volume. Placing a buy and a sell against yourself on the same venue is wash trading. Volume from it is the first thing filtered, and on regulated venues it is market abuse.
• Taker on both legs, 10 rotations a day. You will spend $10k a month to farm a token that might be worth $3k. Fees are the enemy. Fewer, larger, maker-side rotations.
• Farming a venue after the token launched expecting a season-one-sized drop. Second seasons almost always pay less.
• Ignoring the hedge venue’s minimums and precision. An order rounded down to zero means an unhedged leg. Test at $50 first.
• Treating the airdrop as income before it lands. Points are worth nothing until the token trades and you sell it. Budget as if the payout could be zero.

Start today

1. Pick one perp DEX with a live, pre-token points program available in your country, and read its points rules end to end.
2. Open the hedge venue account, create a trade-only, IP-whitelisted API key.
3. Deposit a small test amount on both, run the bot with NOTIONAL_USD = 50 for a week.
4. Once you see a weekly points number, compute cost per point. Scale up only if the number makes sense next to whatever pre-market price exists.

Done right, this is a fee budget swapped for a lottery ticket you can price. Most of the edge comes from paying less per point than everyone farming naked with taker orders, and from not getting liquidated along the way.