Build an OpenClaw Sharp Line Detector Skill — Follow the Smart Money

mkdir -p ~/.openclaw/skills/sharp-line-detector

---
name: sharp-line-detector
description: "Monitor line movements at sharp sportsbooks (Pinnacle, Circa, Bookmaker). Detect steam moves, reverse line movement, and significant implied probability shifts. Use when asked about line movement, sharp money, steam moves, or smart money signals."
metadata:
  openclaw:
    emoji: "🔍"
    requires:
      bins: ["curl", "jq", "python3"]
    credentials:
      - id: "odds-api-key"
        name: "The Odds API Key"
        description: "Free API key from https://the-odds-api.com/"
        env: "ODDS_API_KEY"
---

# Sharp Line Detector

Monitor line movements at sharp sportsbooks. Detect steam moves, reverse line movement, and smart money signals.

# When to Use

Use this skill when the user asks about:
- Line movement on a game or sport
- Steam moves or sharp action
- Reverse line movement (RLM) signals
- Whether smart money has moved a line
- Pinnacle, Circa, or Bookmaker line changes
- Significant odds shifts since open

# Sharp Book Keys

The skill prioritizes lines from these market-making books (in order of sharpness):

| Book | The Odds API Key | Why It Matters |
|------|-----------------|----------------|
| Pinnacle | pinnacle | Lowest vig, sharpest global market |
| Circa | circasports | Sharpest US book, accepts large limits |
| Bookmaker | bookmaker | Long-standing sharp-friendly book |
| BetOnline | betonlineag | Accepts sharp action, moves early |
| DraftKings | draftkings | High volume, useful as public benchmark |
| FanDuel | fanduel | High volume, useful as public benchmark |

If Pinnacle odds are not available in the API response, fall back to Circa, then Bookmaker.

# Configuration

Environment variables for tuning thresholds (all optional):

- SHARP_SPREAD_THRESHOLD — Minimum spread movement in points to flag (default: 1.5)
- SHARP_ML_THRESHOLD — Minimum moneyline implied probability shift to flag (default: 0.05 = 5%)
- SHARP_SNAPSHOT_DIR — Directory for snapshot files (default: /tmp/openclaw-sharp-snapshots)

# Operations

### 1. Snapshot Current Lines

Capture a timestamped snapshot of current odds from all books for a sport. Stores as JSON for later comparison.

```bash
SPORT_KEY="${SPORT_KEY:-basketball_nba}"
SNAP_DIR="${SHARP_SNAPSHOT_DIR:-/tmp/openclaw-sharp-snapshots}"
mkdir -p "$SNAP_DIR"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

curl -s "https://api.the-odds-api.com/v4/sports/$SPORT_KEY/odds?apiKey=$ODDS_API_KEY&regions=us,eu&markets=h2h,spreads&oddsFormat=american&bookmakers=pinnacle,circasports,bookmaker,betonlineag,draftkings,fanduel" \
  | jq --arg ts "$TIMESTAMP" '{
    timestamp: $ts,
    sport: "'$SPORT_KEY'",
    games: [.[] | {
      id: .id,
      game: "\(.away_team) @ \(.home_team)",
      away: .away_team,
      home: .home_team,
      start: .commence_time,
      books: [.bookmakers[] | {
        key: .key,
        name: .title,
        h2h: [(.markets[] | select(.key=="h2h")).outcomes[] | {team: .name, odds: .price}],
        spread: [(.markets[] | select(.key=="spreads")).outcomes[] | {team: .name, point: .point, odds: .price}]
      }]
    }]
  }' > "$SNAP_DIR/${SPORT_KEY}_${TIMESTAMP}.json"

echo "Snapshot saved: ${SPORT_KEY}_${TIMESTAMP}.json ($(jq '.games | length' "$SNAP_DIR/${SPORT_KEY}_${TIMESTAMP}.json") games)"
```

### 2. Detect Line Movements

Compare current odds to the most recent snapshot. Flag games where spread or moneyline moved past thresholds.

```bash
SPORT_KEY="${SPORT_KEY:-basketball_nba}"
SNAP_DIR="${SHARP_SNAPSHOT_DIR:-/tmp/openclaw-sharp-snapshots}"
SPREAD_THRESH="${SHARP_SPREAD_THRESHOLD:-1.5}"
ML_THRESH="${SHARP_ML_THRESHOLD:-0.05}"

## Find latest snapshot
LATEST=$(ls -t "$SNAP_DIR"/${SPORT_KEY}_*.json 2>/dev/null | head -1)
if [ -z "$LATEST" ]; then
  echo "No previous snapshot found for $SPORT_KEY. Run a snapshot first."
  exit 1
fi

echo "Comparing against snapshot: $(basename $LATEST)"

## Fetch current odds
CURRENT=$(curl -s "https://api.the-odds-api.com/v4/sports/$SPORT_KEY/odds?apiKey=$ODDS_API_KEY&regions=us,eu&markets=h2h,spreads&oddsFormat=american&bookmakers=pinnacle,circasports,bookmaker,betonlineag,draftkings,fanduel")

## Compare using Python for math precision
python3 -c "
import json, sys

def american_to_implied(odds):
    if odds < 0:
        return abs(odds) / (abs(odds) + 100)
    else:
        return 100 / (odds + 100)

with open('$LATEST') as f:
    snap = json.load(f)

current = json.loads('''$(echo "$CURRENT" | sed "s/'/'\\\\''/g")''')

spread_thresh = float('$SPREAD_THRESH')
ml_thresh = float('$ML_THRESH')

snap_lookup = {}
for g in snap['games']:
    for b in g['books']:
        if b['key'] == 'pinnacle' or (g['id'] not in snap_lookup):
            snap_lookup[g['id']] = {
                'game': g['game'],
                'h2h': {o['team']: o['odds'] for o in b.get('h2h', [])},
                'spread': {o['team']: {'point': o['point'], 'odds': o['odds']} for o in b.get('spread', [])}
            }

alerts = []
for game in current:
    gid = game['id']
    if gid not in snap_lookup:
        continue
    old = snap_lookup[gid]
    game_label = f\"{game['away_team']} @ {game['home_team']}\"

    for bk in game.get('bookmakers', []):
        if bk['key'] not in ('pinnacle', 'circasports', 'bookmaker'):
            continue

        # Check spread movement
        for mkt in bk.get('markets', []):
            if mkt['key'] == 'spreads':
                for outcome in mkt['outcomes']:
                    team = outcome['name']
                    new_pt = outcome['point']
                    if team in old.get('spread', {}):
                        old_pt = old['spread'][team]['point']
                        delta = abs(new_pt - old_pt)
                        if delta >= spread_thresh:
                            alerts.append({
                                'type': 'STEAM_SPREAD',
                                'game': game_label,
                                'book': bk['title'],
                                'team': team,
                                'old': old_pt,
                                'new': new_pt,
                                'delta': delta
                            })

            if mkt['key'] == 'h2h':
                for outcome in mkt['outcomes']:
                    team = outcome['name']
                    new_odds = outcome['price']
                    if team in old.get('h2h', {}):
                        old_odds = old['h2h'][team]
                        old_imp = american_to_implied(old_odds)
                        new_imp = american_to_implied(new_odds)
                        shift = abs(new_imp - old_imp)
                        if shift >= ml_thresh:
                            direction = 'shortened' if new_imp > old_imp else 'lengthened'
                            alerts.append({
                                'type': 'STEAM_ML',
                                'game': game_label,
                                'book': bk['title'],
                                'team': team,
                                'old_odds': old_odds,
                                'new_odds': new_odds,
                                'prob_shift': f'{shift:.1%}',
                                'direction': direction
                            })

if alerts:
    print(f'🚨 {len(alerts)} SHARP MOVE(S) DETECTED:')
    print()
    for a in alerts:
        if a['type'] == 'STEAM_SPREAD':
            print(f\"  [{a['book']}] {a['game']}\")
            print(f\"    {a['team']} spread: {a['old']} → {a['new']} (moved {a['delta']} pts)\")
        elif a['type'] == 'STEAM_ML':
            print(f\"  [{a['book']}] {a['game']}\")
            print(f\"    {a['team']} ML: {a['old_odds']} → {a['new_odds']} ({a['direction']} {a['prob_shift']})\")
        print()
else:
    print('No significant line movements detected since last snapshot.')
    print(f'Thresholds: spread >= {spread_thresh} pts, ML >= {ml_thresh:.0%} implied prob shift')
"
```

### 3. Detect Reverse Line Movement

Identify games where the line moved opposite to the expected public side. Uses the heuristic that the bigger favorite attracts more public money.

```bash
SPORT_KEY="${SPORT_KEY:-basketball_nba}"
SNAP_DIR="${SHARP_SNAPSHOT_DIR:-/tmp/openclaw-sharp-snapshots}"

LATEST=$(ls -t "$SNAP_DIR"/${SPORT_KEY}_*.json 2>/dev/null | head -1)
if [ -z "$LATEST" ]; then
  echo "No previous snapshot found. Run a snapshot first."
  exit 1
fi

CURRENT=$(curl -s "https://api.the-odds-api.com/v4/sports/$SPORT_KEY/odds?apiKey=$ODDS_API_KEY&regions=us,eu&markets=h2h,spreads&oddsFormat=american&bookmakers=pinnacle,circasports,bookmaker,draftkings,fanduel")

python3 -c "
import json

def american_to_implied(odds):
    if odds < 0:
        return abs(odds) / (abs(odds) + 100)
    else:
        return 100 / (odds + 100)

with open('$LATEST') as f:
    snap = json.load(f)

current = json.loads('''$(echo "$CURRENT" | sed "s/'/'\\\\''/g")''')

snap_lookup = {}
for g in snap['games']:
    for b in g['books']:
        if b['key'] == 'pinnacle' or (g['id'] not in snap_lookup):
            snap_lookup[g['id']] = {
                'game': g['game'],
                'away': g['away'],
                'home': g['home'],
                'h2h': {o['team']: o['odds'] for o in b.get('h2h', [])},
                'spread': {o['team']: o['point'] for o in b.get('spread', [])}
            }

rlm_signals = []
for game in current:
    gid = game['id']
    if gid not in snap_lookup:
        continue
    old = snap_lookup[gid]
    away = game['away_team']
    home = game['home_team']

    # Determine public side from moneyline (bigger favorite = more public)
    current_h2h = {}
    current_spread = {}
    for bk in game.get('bookmakers', []):
        if bk['key'] not in ('pinnacle', 'circasports'):
            continue
        for mkt in bk.get('markets', []):
            if mkt['key'] == 'h2h':
                for o in mkt['outcomes']:
                    current_h2h[o['name']] = o['price']
            if mkt['key'] == 'spreads':
                for o in mkt['outcomes']:
                    current_spread[o['name']] = o['point']

    if not current_h2h or not current_spread:
        continue
    if home not in old.get('spread', {}) or home not in current_spread:
        continue

    # Public side = bigger favorite (lower implied odds / more negative spread)
    home_imp = american_to_implied(current_h2h.get(home, 100))
    away_imp = american_to_implied(current_h2h.get(away, 100))
    public_side = home if home_imp > away_imp else away

    # Check if spread moved TOWARD the public side (normal) or AWAY (RLM)
    old_home_spread = old['spread'].get(home, 0)
    new_home_spread = current_spread.get(home, 0)
    spread_move = new_home_spread - old_home_spread

    # If public is on home, spread should get more negative (more points given)
    # If it got less negative (moved toward home), that's reverse
    if public_side == home and spread_move > 0:
        rlm_signals.append({
            'game': f'{away} @ {home}',
            'public_side': public_side,
            'old_spread': old_home_spread,
            'new_spread': new_home_spread,
            'direction': 'against public (home fav)'
        })
    elif public_side == away and spread_move < 0:
        rlm_signals.append({
            'game': f'{away} @ {home}',
            'public_side': public_side,
            'old_spread': old_home_spread,
            'new_spread': new_home_spread,
            'direction': 'against public (away fav)'
        })

if rlm_signals:
    print(f'🔄 {len(rlm_signals)} REVERSE LINE MOVEMENT SIGNAL(S):')
    print()
    for s in rlm_signals:
        print(f\"  {s['game']}\")
        print(f\"    Public side: {s['public_side']}\")
        print(f\"    Home spread: {s['old_spread']} → {s['new_spread']}\")
        print(f\"    Signal: Line moved {s['direction']}\")
        print()
else:
    print('No reverse line movement detected.')
"
```

### 4. Check Snapshot History

List all stored snapshots for a sport with game counts and timestamps:

```bash
SPORT_KEY="${SPORT_KEY:-basketball_nba}"
SNAP_DIR="${SHARP_SNAPSHOT_DIR:-/tmp/openclaw-sharp-snapshots}"

echo "Snapshots for $SPORT_KEY:"
echo "---"
for f in $(ls -t "$SNAP_DIR"/${SPORT_KEY}_*.json 2>/dev/null | head -10); do
  TS=$(jq -r '.timestamp' "$f")
  GAMES=$(jq '.games | length' "$f")
  echo "  $TS — $GAMES games — $(basename $f)"
done

TOTAL=$(ls "$SNAP_DIR"/${SPORT_KEY}_*.json 2>/dev/null | wc -l)
echo "---"
echo "Total snapshots: $TOTAL"
```

# Output Rules

1. Always identify which sharp book's line is being reported (Pinnacle preferred)
2. Show movement as old → new with delta in both points and implied probability
3. Label steam moves with 🚨 and reverse line movement with 🔄
4. Include the snapshot timestamp so the user knows the comparison window
5. When no movements exceed thresholds, report the current thresholds and suggest adjusting if needed
6. Always report remaining API quota after fetching odds

# Error Handling

- If ODDS_API_KEY is not set, tell the user to get a free key at https://the-odds-api.com/
- If no snapshot exists for the requested sport, prompt the user to run a snapshot first
- If Pinnacle odds are not in the API response, fall back to Circa, then Bookmaker, and note which book is being used
- If rate limited (429), report remaining quota and suggest reducing snapshot frequency
- If the sport is out of season (empty response), inform the user and suggest an active sport

export ODDS_API_KEY=your_key_here

export SHARP_SPREAD_THRESHOLD=1.5   # points of spread movement to flag
export SHARP_ML_THRESHOLD=0.05      # 5% implied probability shift to flag

{
  "cron": "*/15 * * * 0,1,4,5,6",
  "prompt": "Snapshot NBA lines, then check for sharp line movements. If any steam moves detected, alert me with the game, direction, and magnitude."
}

{
  "cron": "*/10 10-13 * * 0",
  "prompt": "Snapshot NFL lines and scan for steam moves and reverse line movement. Flag anything that moved more than 1 point on the spread at Pinnacle."
}