The same on-chain data that powers Solana trading bots — token velocity, wallet accumulation patterns, liquidity movements — can be repurposed as a high-signal source for ad creative strategy. DeFiKit's AutoGunSOL scanner, originally built for real-time trade execution, doubles as a marketing intelligence engine. This post shows you how to bridge the gap between trading infrastructure and ad creative decisions.
The Problem
Marketing teams launching campaigns in the crypto space operate with a severe information asymmetry. They run ads based on trend research, social listening, and gut feel — but the actual market signals live on-chain, inside the same blockchain data that trading bots consume every second.
Most marketing analytics pipelines look like this:
- **Social scraping** — what people are saying on Twitter, Discord, Telegram
- **Trend aggregation** — CoinGecko rankings, DEX screener volume spikes
- **Manual research** — looking at token charts, reading project docs
These are lagging indicators. By the time a trend surfaces on social media, trading bots have already priced it in. Marketing teams chase narratives rather than lead them.
The core problem is structural: marketing tooling and trading infrastructure live in completely separate worlds. The trading team has real-time on-chain data. The marketing team has social listening dashboards. Neither speaks to the other.
The Solution
DeFiKit bridges this gap. The AutoGunSOL scanner — a NestJS-based real-time Solana blockchain scanner — already ingests the raw data that drives profitable trades. By adding a thin analytics layer, that same data flow becomes a creative intelligence feed.
The insight is simple: **wallet behavior patterns predict what will trend before it trends.** When you see accumulation wallets clustering around a new token, or liquidity providers concentrating in a specific pool, those are leading indicators. They tell you which narratives are about to catch fire.
DeFiKit already has the infrastructure for this:
- **Rule engine** — filters transactions based on customizable logic
- **Honeypot detection** — identifies scam/malicious patterns (also useful for brand safety)
- **Liquidity checks** — monitors pool depth and movement
- **Real-time scanning** — WebSocket-based, sub-second data flow
These components were designed for trading. But the data they emit is pure marketing gold.
Architecture
Here's how the pipeline connects scanner data to creative decisions:
```
On-Chain Data (Solana RPC)
↓
AutoGunSOL Scanner (NestJS)
├─ Rule Engine (filters)
├─ Honeypot Detection
├─ Liquidity Checks
└─ Wallet Activity Log
↓
Data Pipeline (PostgreSQL + Redis)
↓
Analytics Layer (Python)
├─ Token Velocity Score
├─ Accumulation Signal
├─ Social Correlation
└─ Creative Opportunity Score
↓
Marketing Dashboard → Ad Creative Decisions
```
The key architectural insight: the scanner doesn't need to change. It already processes every transaction. The new piece is the **analytics pipeline** — a lightweight Python service that reads from the same database and computes marketing-relevant signals.
Step 1: On-Chain Data as Market Signals
Let's look at what raw signals AutoGunSOL already captures and what they mean for marketing:
| Scanner Signal | Marketing Interpretation |
|---|---|
| Token velocity (tx/s) | Early interest — run awareness campaigns |
| Wallet accumulation rate | Building conviction — create educational content |
| LP concentration changes | Institutional interest — push premium positioning |
| Honeypot/match alerts | Scam activity — brand safety filter for ad placements |
| Whale wallet movements | Narrative shift incoming — prepare creative rotation |
The key metric to compute is **Token Velocity Score** — a normalized measure of transaction activity per token over sliding windows. High velocity with increasing wallet count = organic interest, not bot wash-trading.
```python
Simplified token velocity scoring from scanner data
def compute_token_velocity_score(tx_log, token_address, windows=[60, 300, 3600]):
"""
Compute normalized velocity scores for a token across multiple time windows.
Input: transaction log from AutoGunSOL scanner output.
"""
scores = {}
for window in windows:
recent_txs = [
tx for tx in tx_log
if tx["token"] == token_address
and tx["timestamp"] > (time.time() - window)
]
unique_wallets = len(set(tx["from"] for tx in recent_txs))
tx_count = len(recent_txs)
Penalize for bot-like patterns (single wallet, many tx)
bot_factor = min(1.0, unique_wallets / max(1, tx_count * 0.1))
velocity = (tx_count / window) * bot_factor
scores[f"{window}s"] = round(velocity, 4)
return scores
```
This single function, when applied across all watched tokens, gives you a ranked list of which tokens are experiencing genuine organic interest — the exact signal you want for creative targeting.
Step 2: From Trading Bots to Creative Strategy
The pipeline outputs more than raw numbers. Here's how each signal maps to a specific creative decision:
**Accumulation Signal → Awareness Campaign**
When wallets begin accumulating a token at increasing rates, that's a 24–72 hour window before the broader market catches on. Run awareness-stage ads targeting that token's community. Creative angle: "Early to the next big thing."
**Velocity Spike → Performance Campaign**
Sudden velocity spikes, especially on established tokens, signal news or catalyst events. Switch to conversion-focused creatives — direct response, CTA-heavy. The audience is already warmed up.
**LP Concentration → Thought Leadership**
When major liquidity providers concentrate in a pool, it signals institutional confidence. Create authority-building content: deep dives, technical analysis pieces. This is high-intent traffic.
**Honeypot Cluster → Negative Targeting**
If the scanner flags a honeypot scheme around a token, exclude that token from all ad targeting. This protects brand safety and avoids associating your ads with scams.
Implementation
Here's a practical Python pipeline that connects AutoGunSOL's data output to marketing decisions. This assumes the scanner writes to a PostgreSQL database.
```python
import psycopg2
import json
from datetime import datetime, timedelta
from collections import defaultdict
Connect to the same DB AutoGunSOL uses
conn = psycopg2.connect(
dbname="defikit_scanner",
user="scanner_user",
password=os.environ["DB_PASSWORD"],
host="localhost"
)
def get_creative_opportunities(min_score=0.7):
"""
Query AutoGunSOL scanner data and produce ranked
creative opportunities for the marketing team.
"""
cur = conn.cursor()
1. Get token activity from last hour
cur.execute("""
SELECT
token_address,
token_symbol,
COUNT(*) as tx_count,
COUNT(DISTINCT wallet_from) as unique_wallets,
AVG(tx_value_usd) as avg_tx_value
FROM scanner.transactions
WHERE scanned_at > NOW() - INTERVAL '1 hour'
GROUP BY token_address, token_symbol
HAVING COUNT(DISTINCT wallet_from) > 10
ORDER BY COUNT(*) DESC
""")
opportunities = []
for row in cur.fetchall():
token_addr, symbol, tx_count, wallets, avg_value = row
2. Compute organic score
organic_score = min(1.0, wallets / max(1, tx_count * 0.05))
velocity = tx_count / 3600 # per second
if organic_score < min_score:
continue
3. Determine creative strategy
if velocity > 10 and wallets > 50:
strategy = "awareness_campaign"
creative_angle = f"{symbol} is heating up — 50+ new wallets in 1 hour"
elif avg_value > 1000:
strategy = "thought_leadership"
creative_angle = f"Whales moving into {symbol} — analysis piece"
else:
strategy = "community_building"
creative_angle = f"Growing interest in {symbol} — educational content"
opportunities.append({
"token": symbol,
"address": token_addr,
"organic_score": round(organic_score, 2),
"velocity_tps": round(velocity, 3),
"unique_wallets": wallets,
"strategy": strategy,
"creative_angle": creative_angle
})
4. Return ranked by opportunity score
opportunities.sort(key=lambda x: x["organic_score"] * x["velocity_tps"], reverse=True)
return opportunities
Feed this into your ad platform or creative brief generator
for opp in get_creative_opportunities()[:10]:
print(json.dumps(opp, indent=2))
```
This script runs every hour, reads from the same database AutoGunSOL writes to, and outputs ranked creative opportunities. The marketing team gets a daily brief that looks like this:
```
📊 DeFiKit Creative Intelligence Brief — 2026-05-11
───────────────────────────────────────────────
1. TOKEN: BONK | Score: 0.89 | Strategy: awareness_campaign
Angle: "BONK is heating up — 50+ new wallets in 1 hour"
2. TOKEN: PYTH | Score: 0.76 | Strategy: thought_leadership
Angle: "Whales moving into PYTH — technical analysis"
3. TOKEN: JUP | Score: 0.71 | Strategy: community_building
Angle: "Growing interest in JUP — what's driving it"
```
Key Takeaways
1. **Your trading bot is already a marketing tool.** If you run a Solana scanner for trading, the data it generates has more predictive power for creative strategy than any social listening dashboard. You just need to look at it differently.
2. **Wallet behavior leads social sentiment by 24–72 hours.** Accumulation patterns from real wallets predict which narratives will break on social media. Campaigns built on on-chain signals run ahead of the curve, not behind it.
3. **The same pipeline serves both trading and marketing.** DeFiKit's architecture — NestJS scanner → PostgreSQL → analytics layer — means the infrastructure cost is already paid. Adding a marketing intelligence feed is just another consumer on the same data stream.
4. **Organic signals are different from trading signals.** For trading, you want high velocity with low wallet count (bot-friendly). For marketing, you want high velocity with high wallet count (organic interest). Filter appropriately.
5. **Brand safety comes built-in.** AutoGunSOL's honeypot detection, built for protecting trades, doubles as an automated blocklist for ad targeting. Any token flagged by the scanner is automatically excluded from campaign targeting.
DeFiKit started as a trading infrastructure project — Solana bots, Freqtrade strategies, real-time scanners. But the data it generates has a second life as a creative intelligence engine. When your dev tools can feed your marketing strategy directly, you've closed a gap that most teams don't even know they have. The same pipeline that executes trades can also brief your creative team on what to build next.