Guides
API Reference
Start typing to search…

🏁 QuickStart

Generate SEO-optimized betting content automatically

betContent Quickstart Guide

betContent automatically generates SEO-optimized betting content including game previews, player prop analysis, and betting guides. Perfect for media sites, affiliate blogs, and content platforms looking to scale their betting content production.

What's Included

See subscription pricing → for current rates.

  • ✅ Daily game previews for all major leagues
  • ✅ SEO-optimized with meta tags and structured data
  • ✅ Historical analysis and trends
  • ✅ Recommended bets and player props
  • ✅ Customizable tone and branding

Prerequisites

  1. SharpSports account (sign up here)
  2. betContent subscription (see pricing)
  3. Your API keys (found in dashboard)

5-Minute Quickstart

Step 1: Set Up Your Environment

import requests
import json
from datetime import datetime, timedelta

# Use your private key for fetching content
API_KEY = "sk_test_your_key_here"  # Use sk_live_ in production

headers = {
    "Authorization": f"Token {API_KEY}",
    "Content-Type": "application/json"
}

base_url = "https://api.sharpsports.io/v1"

Step 2: Get Available Articles

Find what content is available for today:

def get_todays_articles(league="NFL"):
    # Get articles for today's date
    today = datetime.now().strftime("%Y-%m-%d")

    response = requests.get(
        f"{base_url}/articles",
        headers=headers,
        params={
            "league": league,
            "dateCreated": today
        }
    )

    articles = response.json()

    print(f"Found {len(articles)} {league} articles for {today}")

    for article in articles:
        print(f"- {article['title']} (ID: {article['id']})")

    return articles

# Get today's NFL content
articles = get_todays_articles("NFL")

Step 3: Retrieve Full Article Content

Get the complete article with all metadata:

def get_article_content(article_id):
    response = requests.get(
        f"{base_url}/articles/{article_id}",
        headers=headers
    )

    article = response.json()

    # Display article preview
    print(f"\n📰 {article['title']}")
    print(f"📝 {article['metaDescription']}")
    print(f"🏷️ Keywords: {', '.join(article['keywords'])}")
    print(f"⏱️ Read time: {article['readTimeMinutes']} minutes")
    print(f"\n{article['content'][:500]}...")  # First 500 chars

    return article

# Get the first article's full content
if articles:
    content = get_article_content(articles[0]['id'])

Step 4: Extract Structured Data

Parse the article for specific elements:

def extract_article_sections(article):
    """Extract key sections from the article"""

    sections = {
        "preview": article.get("gamePreview"),
        "where_to_watch": article.get("whereToWatch"),
        "betting_trends": article.get("bettingTrends"),
        "recommended_bets": article.get("recommendedBets"),
        "player_props": article.get("playerProps"),
        "historical_matchup": article.get("historicalMatchup"),
        "injury_report": article.get("injuryReport")
    }

    # Display structured information
    print("\n📊 Article Sections:")

    for section, content in sections.items():
        if content:
            print(f"\n{section.upper().replace('_', ' ')}:")
            if isinstance(content, list):
                for item in content[:3]:  # Show first 3 items
                    print(f"  • {item}")
            elif isinstance(content, dict):
                for key, value in list(content.items())[:3]:
                    print(f"  • {key}: {value}")
            else:
                print(f"  {content[:200]}...")

    return sections

# Extract structured data
if articles:
    sections = extract_article_sections(content)

Step 5: Prepare for Publishing

Format the content for your CMS:

def prepare_for_cms(article):
    """Prepare article for WordPress or other CMS"""

    cms_data = {
        "title": article["title"],
        "content": article["content"],
        "excerpt": article["metaDescription"],
        "author": "SharpSports AI",
        "categories": ["Sports Betting", article["league"]],
        "tags": article["keywords"],
        "meta": {
            "meta_title": article["metaTitle"],
            "meta_description": article["metaDescription"],
            "og_title": article["title"],
            "og_description": article["metaDescription"],
            "og_image": article.get("featuredImage", ""),
            "twitter_title": article["title"],
            "twitter_description": article["metaDescription"],
        },
        "schema": {
            "@context": "https://schema.org",
            "@type": "NewsArticle",
            "headline": article["title"],
            "datePublished": article["dateCreated"],
            "dateModified": article["dateModified"],
            "author": {
                "@type": "Organization",
                "name": "SharpSports"
            },
            "description": article["metaDescription"],
            "mainEntityOfPage": {
                "@type": "WebPage",
                "@id": f"https://yoursite.com/articles/{article['id']}"
            }
        },
        "custom_fields": {
            "game_time": article.get("gameTime"),
            "home_team": article.get("homeTeam"),
            "away_team": article.get("awayTeam"),
            "recommended_bet": article.get("recommendedBets", [{}])[0]
        }
    }

    return cms_data

# Prepare for publishing
if articles:
    cms_ready = prepare_for_cms(content)
    print("\n✅ Article ready for CMS import")
    print(f"Title: {cms_ready['title']}")
    print(f"Categories: {', '.join(cms_ready['categories'])}")
    print(f"Tags: {', '.join(cms_ready['tags'][:5])}")

Complete Working Example

Here's a full content publishing workflow:

import requests
from datetime import datetime, timedelta
import time

class BetContentClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.sharpsports.io/v1"
        self.headers = {
            "Authorization": f"Token {api_key}",
            "Content-Type": "application/json"
        }

    def get_weekly_content(self, league, days_ahead=7):
        """Get all content for the next week"""
        articles = []

        for day in range(days_ahead):
            date = (datetime.now() + timedelta(days=day)).strftime("%Y-%m-%d")

            response = requests.get(
                f"{self.base_url}/articles",
                headers=self.headers,
                params={
                    "league": league,
                    "dateCreated": date
                }
            )

            daily_articles = response.json()
            articles.extend(daily_articles)

        return articles

    def publish_to_wordpress(self, article, wp_api_url, wp_auth):
        """Publish article to WordPress via REST API"""

        # Prepare WordPress post
        post_data = {
            "title": article["title"],
            "content": article["content"],
            "excerpt": article["metaDescription"],
            "status": "draft",  # Or "publish" for immediate publishing
            "categories": [5, 12],  # Your category IDs
            "tags": [23, 45, 67],  # Your tag IDs
            "meta": {
                "_yoast_wpseo_title": article["metaTitle"],
                "_yoast_wpseo_metadesc": article["metaDescription"]
            }
        }

        # POST to WordPress
        wp_headers = {
            "Authorization": f"Basic {wp_auth}",
            "Content-Type": "application/json"
        }

        response = requests.post(
            f"{wp_api_url}/wp-json/wp/v2/posts",
            headers=wp_headers,
            json=post_data
        )

        if response.status_code == 201:
            post = response.json()
            print(f"✅ Published: {post['link']}")
            return post['id']
        else:
            print(f"❌ Failed to publish: {response.status_code}")
            return None

    def schedule_daily_content(self, league):
        """Automatically publish content each morning"""

        while True:
            now = datetime.now()

            # Publish at 8 AM
            if now.hour == 8 and now.minute == 0:
                today = now.strftime("%Y-%m-%d")

                # Get today's articles
                response = requests.get(
                    f"{self.base_url}/articles",
                    headers=self.headers,
                    params={
                        "league": league,
                        "dateCreated": today
                    }
                )

                articles = response.json()

                for article in articles:
                    # Get full content
                    full_article = requests.get(
                        f"{self.base_url}/articles/{article['id']}",
                        headers=self.headers
                    ).json()

                    # Publish to your CMS
                    print(f"📰 Publishing: {full_article['title']}")
                    # self.publish_to_wordpress(full_article, wp_url, wp_auth)

                    time.sleep(60)  # Space out publishing

            # Check every minute
            time.sleep(60)

# Initialize client
client = BetContentClient("sk_test_your_key_here")

# Get this week's NFL content
weekly_content = client.get_weekly_content("NFL")
print(f"\n📅 Found {len(weekly_content)} articles for the next 7 days")

# Group by date
by_date = {}
for article in weekly_content:
    date = article['dateCreated']
    if date not in by_date:
        by_date[date] = []
    by_date[date].append(article)

# Display content calendar
print("\n📆 Content Calendar:")
for date in sorted(by_date.keys()):
    articles = by_date[date]
    print(f"\n{date}:")
    for article in articles:
        print(f"  • {article['title']}")

Content Types

Game Previews

  • Comprehensive pre-game analysis
  • Head-to-head statistics
  • Recent form and trends
  • Key player matchups
  • Weather conditions (outdoor sports)

Player Props Analysis

  • Statistical projections
  • Recent performance trends
  • Matchup advantages
  • Injury considerations
  • Recommended over/under picks

Customization Options

Configure in Dashboard

All betContent customization is managed through your SharpSports dashboard. Navigate to Settings > BetContent to configure:

Email Delivery:

  • Primary email for article delivery
  • CC emails for additional recipients

Content Preferences:

  • Leagues to cover (NFL, NBA, MLB, NHL, Soccer, etc.)
  • Article title templates
  • Custom lede text

Article Features:

  • Include/exclude betting odds
  • Include/exclude game information
  • Include/exclude trends analysis (season, last 5, or last 10 games)
  • Include/exclude head-to-head matchup history
  • Include/exclude player prop recommendations

Pick Recommendations:

  • Pick type (Public Consensus or Money Line Movement)
  • Custom section titles

Player Prop Settings:

  • Number of props to include (1-10)
  • Custom prop section titles

No API configuration required - all settings are managed through the dashboard interface.

SEO Optimization

All content includes:

  • Title tags optimized for search
  • Meta descriptions under 160 characters
  • Structured data (Schema.org NewsArticle)
  • Internal linking opportunities
  • Keywords naturally integrated
  • Readability score optimization

Best Practices

  1. Schedule Publishing: Publish content 2-4 hours before game time
  2. Update Post-Game: Add results and analysis after games
  3. Cross-Link Content: Link between related articles
  4. Monitor Performance: Track which content drives engagement
  5. A/B Test Headlines: Test different titles for better CTR

Next Steps

  1. Set up automation: Schedule daily content publishing
  2. Customize voice: Work with our team to match your brand
  3. Track performance: Monitor engagement and conversions
  4. Expand coverage: Add more leagues and bet types

Need Help?

Updated 4 days ago