Sports handicapping companies face a unique challenge: converting winning picks into engaging social content fast enough to capitalize on momentum. Manual screenshot editing, caption writing, and posting eats up hours that should be spent on analysis. This AI marketing agent solves that problem by automating the entire content pipeline from betting screenshots to published Instagram stories. You'll learn how to build a complete system that maintains your brand voice while scaling output 10x.
The Problem: Manual Content Creation Kills Marketing Momentum
Sports handicapping marketing requires speed and consistency. A winning pick needs to become social proof within minutes, not hours.
Current challenges:
- Screenshots sit in folders for hours before someone edits them
- Caption quality varies wildly depending on who writes it
- Brand voice inconsistency confuses followers and reduces trust
- Manual posting means missing optimal engagement windows
- Creating email campaigns from winning picks takes 2-3 hours per send
- No systematic way to test different offers and CTAs
Business impact:
- Time spent: 15-20 hours/week on content creation and posting
- Missed revenue: Late posts lose 60-70% of potential engagement
- Inconsistent output: 3-5 posts/week instead of daily content
- Brand dilution: Multiple writers create voice inconsistency
The manual process can't scale. You need automation that preserves quality while multiplying output.
The Solution Overview
This n8n AI agent creates a complete marketing automation pipeline. It receives betting screenshots, processes them with AI vision models, generates brand-consistent captions and graphics, and prepares Instagram-ready content packages. The system uses OpenAI's GPT-4 for copywriting, integrates with design tools for graphics, and connects to Instagram's API for automated posting. The workflow maintains a brand voice database that learns from your best-performing content. You'll build a system that turns one screenshot into multiple content formats—Stories, Reels, emails, and engagement posts—in under 60 seconds.
What You'll Build
This AI marketing agent handles the complete content creation and distribution pipeline for sports handicapping companies.
| Component | Technology | Purpose |
|---|---|---|
| Screenshot Ingestion | Webhook/Email Parser | Receives betting screenshots automatically |
| AI Vision Analysis | OpenAI GPT-4 Vision | Extracts pick details, odds, and context |
| Content Generation | OpenAI GPT-4 | Writes captions, CTAs, email copy |
| Brand Voice Engine | Vector Database (Pinecone/Supabase) | Maintains consistent tone across content |
| Design Automation | Canva API/Bannerbear | Creates Instagram-ready graphics |
| Social Scheduling | Instagram Graph API/Buffer | Publishes Stories, Reels, and posts |
| Email Marketing | Klaviyo/Mailchimp API | Sends automated campaigns |
| Performance Tracking | Google Sheets/Airtable | Logs content and engagement metrics |
Key capabilities:
- Transform screenshots into 5+ content variations in 60 seconds
- Generate captions that match your established brand voice
- Create custom graphics with your branding automatically
- Draft email campaigns from winning picks
- Suggest A/B test variations for offers and CTAs
- Produce engagement content (polls, questions, challenges)
- Maintain content calendar and posting schedule
Prerequisites
Before starting, ensure you have:
- n8n instance (cloud or self-hosted)
- OpenAI API account with GPT-4 Vision access
- Instagram Business account with Graph API credentials
- Canva Pro account or Bannerbear API access
- Email marketing platform (Klaviyo or Mailchimp) with API key
- Google Drive or Dropbox for screenshot storage
- Pinecone or Supabase account for vector database (brand voice storage)
- Basic JavaScript knowledge for Function nodes
- Understanding of prompt engineering for consistent AI outputs
Step 1: Set Up Screenshot Ingestion Pipeline
The workflow starts by receiving betting screenshots through multiple channels. You need flexible input methods because screenshots come from various sources—mobile uploads, email forwards, or direct API submissions.
Configure Webhook Trigger
- Add a Webhook node as your primary trigger
- Set HTTP Method to POST
- Enable "Respond Immediately" to confirm receipt
- Configure authentication with a secret token
Node configuration:
{
"httpMethod": "POST",
"path": "sports-screenshot-intake",
"authentication": "headerAuth",
"responseMode": "responseNode",
"options": {
"allowedOrigins": "https://yourdomain.com"
}
}
Add Email Parser Alternative
- Create an Email Trigger node for forwarded screenshots
- Configure IMAP settings for your dedicated intake email
- Set filter for subject line containing "Pick" or "Screenshot"
- Extract attachments automatically
Why this works:
Multiple intake methods ensure no screenshot gets lost. The webhook handles automated submissions from betting platforms. The email parser catches manual forwards from your phone or team members. Both routes converge into the same processing pipeline.
Set Up File Storage
- Add a Google Drive or Dropbox node
- Create folder structure:
/screenshots/raw/[date]/ - Upload incoming images with timestamp naming
- Generate shareable links for downstream processing
This creates an audit trail and backup system. Every screenshot is preserved with metadata before AI processing begins.
Step 2: AI Vision Analysis and Data Extraction
GPT-4 Vision extracts structured data from betting screenshots. This eliminates manual data entry and ensures accuracy.
Configure OpenAI Vision Node
- Add an OpenAI node set to GPT-4 Vision model
- Pass the screenshot URL from previous step
- Use structured prompt for consistent extraction
Extraction prompt template:
Analyze this sports betting screenshot and extract:
- Sport and league
- Teams/players involved
- Bet type (spread, moneyline, over/under, prop)
- Odds and stake amount
- Timestamp of bet placement
- Current status (pending, won, lost)
- Any visible profit/loss amounts
Return as JSON with these exact keys:
{
"sport": "",
"league": "",
"matchup": "",
"bet_type": "",
"selection": "",
"odds": "",
"stake": "",
"status": "",
"profit_loss": "",
"timestamp": ""
}
Add Data Validation Function
- Insert a Function node after OpenAI
- Validate all required fields are present
- Format odds consistently (American format)
- Calculate implied probability and potential payout
Function node code:
const data = $input.item.json;
// Validate required fields
const required = ['sport', 'matchup', 'bet_type', 'odds', 'stake'];
const missing = required.filter(field => !data[field]);
if (missing.length > 0) {
throw new Error(`Missing required fields: ${missing.join(', ')}`);
}
// Standardize odds format
data.odds_formatted = data.odds.startsWith('+') || data.odds.startsWith('-')
? data.odds
: `+${data.odds}`;
// Calculate potential payout
const stake = parseFloat(data.stake.replace(/[^0-9.]/g, ''));
const odds = parseInt(data.odds_formatted);
data.potential_payout = odds > 0
? (stake * (odds / 100)).toFixed(2)
: (stake / (Math.abs(odds) / 100)).toFixed(2);
return { json: data };
Why this approach:
Vision AI eliminates transcription errors that plague manual data entry. Structured JSON output feeds directly into content generation. Validation catches edge cases before they break downstream processes. Consistent formatting ensures graphics render correctly.
Step 3: Brand Voice Engine and Content Generation
The brand voice engine maintains consistency across all generated content. It uses vector similarity search to match new content against your best-performing historical posts.
Build Brand Voice Database
- Add a Pinecone or Supabase Vector Store node
- Create embeddings from your top 50-100 posts
- Store with metadata: engagement rate, post type, offer details
Initial setup code:
// Sample brand voice entries
const brandSamples = [
{
text: "🔥 ANOTHER WINNER! Lakers -4.5 CASHES. That's 7-2 this week. Link in bio for tomorrow's locks.",
metadata: { engagement_rate: 8.2, post_type: "win_announcement", tone: "confident" }
},
{
text: "Breaking down tonight's Celtics game. Why the over 218.5 is the play. Full analysis in stories.",
metadata: { engagement_rate: 6.5, post_type: "analysis_preview", tone: "educational" }
}
// Add 48-98 more samples
];
// Generate embeddings and store
for (const sample of brandSamples) {
const embedding = await generateEmbedding(sample.text);
await vectorStore.upsert({
id: generateId(),
values: embedding,
metadata: sample.metadata
});
}
Configure Content Generation Chain
- Add OpenAI node for caption generation
- Query vector database for similar high-performing content
- Inject brand voice examples into prompt context
- Generate 3-5 caption variations
Caption generation prompt:
You are a sports handicapping content creator. Generate Instagram captions for this winning bet:
BET DETAILS:
${JSON.stringify(extractedData)}
BRAND VOICE EXAMPLES (high engagement):
${brandVoiceExamples.map(ex => `- ${ex.text} (${ex.metadata.engagement_rate}% engagement)`).join('
')}
Generate 3 caption variations:
1. Celebration post (short, punchy, emoji-heavy)
2. Educational breakdown (explain the reasoning)
3. Call-to-action (drive link clicks)
Each caption must:
- Match the confident, knowledgeable tone from examples
- Include relevant emoji (max 3)
- End with clear CTA
- Be under 150 characters for Stories
Return as JSON array.
Add Offer and CTA Generator
- Create a Function node to rotate offers
- Pull from predefined offer library
- Match offer type to content context (win = social proof, analysis = expertise)
Variables to customize:
tone_intensity: Adjust from "conservative" to "aggressive" based on audienceemoji_density: Control emoji usage (0-5 per caption)cta_rotation: Cycle through different calls-to-action to prevent fatigue
Step 4: Design Automation and Graphics Creation
Transform extracted data and captions into Instagram-ready graphics using Canva API or Bannerbear.
Configure Canva API Integration
- Add HTTP Request node for Canva API
- Select template ID for Instagram Story format (1080x1920)
- Map data fields to template placeholders
API request structure:
{
"method": "POST",
"url": "https://api.canva.com/v1/designs/{{templateId}}/autofill",
"headers": {
"Authorization": "Bearer {{canvaApiKey}}",
"Content-Type": "application/json"
},
"body": {
"data": {
"matchup": "{{$json.matchup}}",
"bet_type": "{{$json.bet_type}}",
"odds": "{{$json.odds_formatted}}",
"status": "{{$json.status}}",
"profit": "{{$json.potential_payout}}",
"caption": "{{$json.selected_caption}}"
}
}
}
Create Multiple Format Variations
- Add a Loop node to generate 3-5 design variations
- Cycle through different template IDs (Story, Reel, Feed Post)
- Adjust text sizing and positioning per format
Template mapping table:
| Format | Dimensions | Template Use Case | Key Elements |
|---|---|---|---|
| Story | 1080x1920 | Quick win announcements | Large odds, minimal text |
| Reel Cover | 1080x1920 | Video thumbnail | Bold headline, team logos |
| Feed Post | 1080x1080 | Detailed breakdowns | Stats table, analysis text |
| Email Header | 600x400 | Campaign graphics | Branding, offer highlight |
Add Branding Overlay
- Insert Function node to add watermark
- Overlay logo in consistent position
- Add website URL footer to all graphics
Why this works:
Template-based design ensures brand consistency while allowing content variation. Multiple format generation from one data source maximizes content output. Automated branding prevents the "forgot to add logo" mistake that dilutes brand recognition.
Workflow Architecture Overview
This workflow consists of 47 nodes organized into 6 main sections:
- Screenshot ingestion (Nodes 1-8): Webhook and email triggers receive screenshots, upload to cloud storage, generate shareable URLs
- AI vision processing (Nodes 9-15): GPT-4 Vision extracts bet details, validates data, calculates payouts
- Brand voice matching (Nodes 16-24): Vector database queries find similar high-performing content, injects examples into generation context
- Content generation (Nodes 25-35): Creates 3-5 caption variations, generates CTAs, produces email copy, drafts engagement posts
- Design automation (Nodes 36-42): Canva API creates graphics in multiple formats, adds branding overlays
- Distribution preparation (Nodes 43-47): Formats content for Instagram API, schedules posts, logs to tracking sheet
Execution flow:
- Trigger: Webhook POST or new email with attachment
- Average run time: 45-60 seconds for complete content package
- Key dependencies: OpenAI API, Canva API, vector database, cloud storage
Critical nodes:
- OpenAI Vision (Node 11): Extracts structured data from screenshots—accuracy here determines downstream quality
- Vector Store Query (Node 18): Retrieves brand voice examples—similarity threshold of 0.75+ ensures voice consistency
- Content Generator (Node 27): Produces all copy variations—prompt engineering here controls tone and CTA effectiveness
- Canva Autofill (Node 38): Creates graphics—template selection determines visual consistency
The complete n8n workflow JSON template is available at the bottom of this article.
Key Configuration Details
OpenAI API Settings
Required fields:
- Model:
gpt-4-vision-previewfor screenshot analysis,gpt-4-turbofor content generation - Max tokens: 1500 for vision analysis, 800 for caption generation
- Temperature: 0.3 for data extraction (consistency), 0.7 for creative content (variation)
Common issues:
- Using GPT-3.5 for vision → Results in poor data extraction accuracy
- Temperature too high on extraction → Inconsistent JSON structure breaks validation
- Insufficient max tokens → Truncated captions that cut off CTAs
Vector Database Configuration
Pinecone setup:
- Index dimension: 1536 (matches OpenAI ada-002 embeddings)
- Metric: cosine similarity
- Top K results: 5 (retrieves 5 most similar brand voice examples)
Query optimization:
const queryVector = await openai.embeddings.create({
model: "text-embedding-ada-002",
input: `${extractedData.sport} ${extractedData.bet_type} win announcement`
});
const matches = await pinecone.query({
vector: queryVector.data[0].embedding,
topK: 5,
filter: {
engagement_rate: { $gte: 6.0 } // Only use high-performing examples
}
});
Why this approach:
Semantic search finds tonally similar content, not just keyword matches. Filtering by engagement rate ensures you're learning from what actually works. Five examples provide enough context without overwhelming the generation prompt.
Instagram API Integration
Authentication requirements:
- App ID and App Secret from Meta Developer Portal
- User Access Token with
instagram_basic,instagram_content_publishpermissions - Instagram Business Account ID (not personal account)
Posting endpoint:
// Step 1: Create media container
POST https://graph.facebook.com/v18.0/{ig-user-id}/media
{
"image_url": "{{designUrl}}",
"caption": "{{finalCaption}}",
"access_token": "{{accessToken}}"
}
// Step 2: Publish container
POST https://graph.facebook.com/v18.0/{ig-user-id}/media_publish
{
"creation_id": "{{containerId}}",
"access_token": "{{accessToken}}"
}
Rate limits:
- 25 API calls per user per hour for media publishing
- Implement retry logic with exponential backoff
- Queue posts if approaching limit
Testing & Validation
Component testing sequence:
- Screenshot ingestion test: Upload sample betting screenshots through webhook and email, verify cloud storage upload and URL generation
- Vision extraction validation: Run 10 diverse screenshots (different sports, bet types, platforms), check JSON structure completeness and accuracy
- Brand voice consistency: Generate 20 captions from same data, compare tone and structure against historical posts
- Design output review: Inspect all format variations (Story, Reel, Feed), verify branding elements and text readability
- End-to-end dry run: Process screenshot through complete workflow without publishing, review all outputs
Common issues and fixes:
| Issue | Symptom | Solution |
|---|---|---|
| Vision extraction fails | Empty JSON or missing fields | Increase max tokens to 2000, improve image quality (min 1080px width) |
| Brand voice drift | Generated captions don't match tone | Add more diverse examples to vector database (minimum 50 samples) |
| Canva API timeout | Design generation fails after 30s | Reduce template complexity, increase timeout to 60s |
| Instagram publish error | "Invalid media URL" | Ensure design URLs are publicly accessible, not behind authentication |
Validation checklist:
- All extracted data fields populate correctly
- Generated captions match brand voice (run through tone analyzer)
- Graphics render correctly on mobile (test on actual device)
- CTAs include correct tracking links
- Emoji render properly across platforms
- Posting schedule respects rate limits
Production Deployment Checklist
| Area | Requirement | Why It Matters |
|---|---|---|
| Error Handling | Retry logic with exponential backoff on all API calls | Prevents data loss when APIs are temporarily unavailable |
| Monitoring | Webhook health checks every 5 minutes, Slack alerts on failures | Detect failures within minutes instead of discovering them days later |
| Rate Limiting | Queue system for Instagram API (max 20 posts/hour) | Prevents account suspension from exceeding platform limits |
| Data Backup | Daily export of all generated content to Google Sheets | Preserves content history for performance analysis |
| API Key Rotation | Store credentials in n8n credentials manager, rotate quarterly | Reduces security risk from compromised keys |
| Logging | Capture all AI prompts and responses for 30 days | Enables debugging and prompt optimization |
| Fallback Content | Library of 50+ pre-approved posts for AI generation failures | Ensures consistent posting schedule even during outages |
Production environment variables:
{
"OPENAI_API_KEY": "sk-...",
"CANVA_API_KEY": "...",
"INSTAGRAM_ACCESS_TOKEN": "...",
"PINECONE_API_KEY": "...",
"WEBHOOK_SECRET": "...",
"ERROR_NOTIFICATION_WEBHOOK": "https://hooks.slack.com/..."
}
Use Cases & Variations
Use Case 1: Daily Picks Content Pipeline
- Industry: Sports handicapping subscription service
- Scale: 5-10 picks per day, 50-70 social posts per week
- Modifications needed: Add scheduling logic to space posts 2-3 hours apart, integrate with Calendly for consultation booking CTAs, connect to Stripe for tracking conversion from content to sales
Use Case 2: Live Game Commentary Automation
- Industry: In-game betting advisory
- Scale: 20-30 live updates per game, 3-5 games per day
- Modifications needed: Replace screenshot trigger with live odds API webhook, reduce generation time to under 15 seconds, add real-time score integration, create urgent/breaking news post templates
Use Case 3: Email Campaign Generation from Winning Streaks
- Industry: Premium picks service with email list
- Scale: 2-3 email campaigns per week to 5,000+ subscribers
- Modifications needed: Add aggregation logic to collect week's wins, generate email-specific long-form content (500-800 words), integrate with Klaviyo for segmentation (send different content to free vs paid subscribers), A/B test subject lines
Use Case 4: Multi-Sport Content Diversification
- Industry: Full-service handicapping covering 6+ sports
- Scale: 100+ posts per week across all sports
- Modifications needed: Sport-specific brand voice databases (basketball tone differs from baseball), custom graphic templates per sport, audience segmentation (post NFL content to different channels than NBA), seasonal scheduling logic
Customizations & Extensions
Alternative Integrations
Instead of Canva API:
- Bannerbear: Best for high-volume generation (500+ images/day)—requires swapping HTTP Request node configuration to Bannerbear endpoints
- Placid.app: Better if you need video generation—add video template support, increases node count by 8
- Custom Pillow/ImageMagick: Use when you want complete design control—requires Python or Bash node, steeper learning curve
Instead of Pinecone:
- Supabase pgvector: Better if you already use Supabase—native PostgreSQL integration, swap Pinecone nodes for Supabase SQL queries
- Weaviate: Use when you need more complex filtering—supports hybrid search (vector + keyword), requires Docker deployment
- Qdrant: Best for self-hosted solutions—complete data ownership, similar API to Pinecone
Workflow Extensions
Add automated A/B testing:
- Insert a Split node after content generation to create test variants
- Track performance metrics (engagement rate, click-through rate) in Airtable
- Use Function node to calculate statistical significance after 100+ impressions
- Automatically promote winning variants to primary templates
- Nodes needed: +7 (Split, Airtable x3, Function x2, Merge)
Scale to handle video content:
- Add video editing API (Shotstack or Creatomate)
- Process betting screenshots into 15-30 second Reels with motion graphics
- Add voiceover generation using ElevenLabs API
- Automatic captioning with Deepgram transcription
- Performance improvement: Video content gets 3-5x engagement vs static images
- Nodes needed: +12 (HTTP Request x4, Function x3, File operations x5)
Integration possibilities:
| Add This | To Get This | Complexity |
|---|---|---|
| Slack notifications | Real-time alerts when high-value content is generated | Easy (2 nodes) |
| Airtable content calendar | Visual planning and approval workflow before posting | Medium (6 nodes) |
| Google Analytics tracking | UTM parameter generation and conversion tracking | Medium (4 nodes) |
| Telegram channel posting | Reach audience on additional platform with same content | Easy (3 nodes) |
| TikTok API integration | Cross-post Reels to TikTok automatically | Hard (10 nodes) |
| Stripe webhook integration | Trigger special content for new subscriber milestones | Medium (5 nodes) |
Performance optimization for high volume:
Batch processing mode:
- Process 10-20 screenshots simultaneously instead of one at a time
- Add Queue node to manage concurrent API requests
- Implement connection pooling for database queries
- Performance improvement: 5x faster for bulk content creation sessions
- Nodes needed: +8 (Queue, Loop, Merge, Function x5)
Caching layer:
- Store generated captions for similar bet types (e.g., all "Lakers -4.5" bets use similar language)
- Check cache before calling OpenAI API
- Reduces API costs by 40-60% for repetitive content
- Nodes needed: +4 (Redis or Supabase cache lookup, conditional routing)
Get Started Today
Ready to automate your sports handicapping marketing?
- Download the template: Scroll to the bottom of this article to copy the complete n8n workflow JSON
- Import to n8n: Go to Workflows → Import from URL or File, paste the JSON
- Configure your services: Add API credentials for OpenAI, Canva, Instagram Graph API, and your vector database
- Populate brand voice database: Upload 50-100 of your best-performing posts to establish baseline tone
- Test with sample screenshots: Run 5-10 diverse betting screenshots through the workflow to verify accuracy
- Deploy to production: Set up webhook endpoint, configure error notifications, activate the workflow
Customization support:
This workflow is a foundation. Your specific needs—whether that's integration with your existing CRM, custom graphic templates, or multi-platform posting—require tailored modifications.
Need help customizing this workflow for your specific sports handicapping business? Schedule an intro call with Atherial at https://atherial.ai/contact