How to Connect Your AI Agent to Outpacer (MCP + API Guide)

Connecting your AI agent to Outpacer transforms manual SEO tasks into automated workflows that run 24/7. Whether you're generating 50 articles at once, bulk-approving content, or running competitive analysis across 20 competitors simultaneously, an AI agent handles the repetitive work while you focus on strategy.

This guide walks you through both connection methods: the REST API with Bearer token authentication across 28 endpoints, and the newer MCP (Model Context Protocol) server that integrates directly with Claude Desktop. I've tested both approaches extensively, and each serves different use cases depending on your technical setup and automation goals.

Why Connect an AI Agent to Outpacer

The manual approach to content marketing eats up 15-20 hours per week for most marketers. Creating individual articles, checking competitor rankings, and managing content calendars requires constant clicking between interfaces. An AI agent eliminates this friction by executing batch operations in minutes rather than hours.

Automation Benefits You'll See Immediately:

• Generate 10-50 articles simultaneously based on keyword lists
• Auto-approve articles that meet your quality thresholds
• Schedule content publication across multiple websites
• Run daily competitor tracking for 50+ domains
• Execute bulk SEO optimizations across existing content

Bulk Operations That Save Hours: Your agent can process entire content calendars in one command. I've watched teams reduce their weekly content production time from 12 hours to 90 minutes using automated article generation. The agent creates articles, optimizes for target keywords, and schedules publication—all while you handle higher-level strategy.

Custom Workflow Examples:

• Morning Reports: Agent pulls overnight ranking changes, competitor moves, and content performance metrics
• Content Pipeline: Automatically generates articles when competitor gaps are detected
• Quality Control: Reviews drafts against brand guidelines and flags issues before publication
• Performance Optimization: Updates existing articles when search rankings drop below position 5

The real power emerges when you chain multiple operations together. Your agent might detect a competitor ranking for your target keyword, analyze their content structure, generate a superior article, and schedule it for publication—all triggered by a single ranking alert.

Understanding the Two Connection Methods

Outpacer offers two distinct paths for AI agent integration, each optimized for different technical environments and use cases. The REST API provides maximum flexibility with 28 endpoints covering every platform feature, while the MCP server delivers native Claude integration with less setup overhead.

REST API Approach:

• Works with any programming language or AI framework
• Requires API key generation and Bearer token management
• Full access to all 28 endpoints (websites, articles, competitors, tools)
• Perfect for custom applications and complex automation workflows
• Handles high-volume operations with proper rate limiting

MCP Server Approach:

• Native integration with Claude Desktop and Claude Code environments
• Zero authentication setup after initial configuration
• Streamlined for conversational AI interactions
• Ideal for rapid prototyping and ad-hoc content operations
• Limited to MCP-compatible AI systems

The choice depends on your technical stack. If you're building custom automation tools or working with multiple AI platforms, the REST API offers complete control. For Claude-based workflows focused on content creation and optimization, MCP provides the fastest path to productivity.

Method 1: REST API Connection

Generating Your API Key

Navigate to your Outpacer account settings and locate the API section in the left sidebar. Click "Generate New Key" and copy the resulting token immediately—Outpacer displays it only once for security reasons. Store this key in your environment variables or secure credential manager.

The API key format follows this pattern: opt_live_1234567890abcdef... for production keys or opt_test_... for sandbox environments. Each key includes automatic rate limiting at 1000 requests per hour, which resets every 60 minutes. You can monitor usage through the same settings panel where you generated the key.

Bearer Token Authentication

Every API request requires Bearer token authentication in the request header. The format remains consistent across all 28 endpoints:

curl -H "Authorization: Bearer opt_live_your_api_key_here" \
     -H "Content-Type: application/json" \
     https://api.outpacer.ai/v1/websites

Authentication Error Handling: Your code should catch 401 Unauthorized responses and pause operations when authentication fails. I've seen agents get temporarily blocked after sending requests with malformed tokens, so validate your Bearer header format before deployment.

import requests

headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json'
}

def make_api_call(endpoint, method='GET', data=None):
    try:
        response = requests.request(method, f'https://api.outpacer.ai/v1/{endpoint}', 
                                  headers=headers, json=data)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print("Authentication failed. Check your API key.")
        return None

The 28 Available Endpoints

Website Management (4 endpoints):

• GET /websites - List all connected websites
• POST /websites - Add new website to your account
• GET /websites/{id} - Retrieve specific website details
• DELETE /websites/{id} - Remove website from account

Article Operations (8 endpoints):

• GET /articles - List articles with filtering options
• POST /articles - Create new article from keyword or topic
• GET /articles/{id} - Get specific article content and metadata
• PUT /articles/{id} - Update article content or settings
• POST /articles/{id}/approve - Approve draft article for publication
• POST /articles/{id}/publish - Publish approved article to website
• GET /articles/{id}/seo-score - Calculate SEO optimization score
• DELETE /articles/{id} - Remove article from system

Content Planning (5 endpoints):

• GET /content-plans - List active content calendars
• POST /content-plans - Create new content plan from keyword list
• GET /content-plans/{id} - View detailed content plan
• POST /content-plans/{id}/execute - Generate all articles in plan
• PUT /content-plans/{id} - Update plan settings or keywords

Competitor Research (6 endpoints):

• GET /competitors - List tracked competitor domains
• POST /competitors - Add competitor for tracking
• GET /competitors/{id}/rankings - Current ranking positions
• GET /competitors/{id}/content-gaps - Find content opportunities
• POST /competitors/{id}/analyze - Run comprehensive competitor analysis
• DELETE /competitors/{id} - Stop tracking competitor

SEO Tools Integration (5 endpoints):

• POST /tools/keyword-research - Research keywords and search volumes
• POST /tools/content-optimize - Optimize existing content for target keywords
• POST /tools/backlink-analysis - Analyze backlink profiles
• GET /tools/serp-features - Check SERP features for keywords
• POST /tools/site-audit - Run technical SEO audit

Each endpoint accepts specific parameters and returns structured JSON responses. The documentation includes complete request/response examples for every endpoint.

Method 2: MCP Server Setup

What is MCP (Model Context Protocol)

Model Context Protocol represents a standardized way for AI models to interact with external tools and data sources. Think of it as a universal translator between Claude (or other MCP-compatible AIs) and third-party applications like Outpacer.

MCP eliminates the authentication complexity you face with direct API integration. Instead of managing Bearer tokens and endpoint URLs, your AI agent communicates through a local server that handles all the technical details. The agent simply asks "create an article about keyword research" and the MCP server translates that into the appropriate API calls.

Key MCP Advantages:

• No API key management in your conversations
• Natural language commands instead of technical API calls
• Automatic error handling and retry logic
• Real-time responses without polling delays
• Built-in rate limiting to prevent API abuse

The protocol works through a local server process that runs on your machine. This server maintains the connection to Outpacer's API while presenting a simplified interface to your AI agent. You configure authentication once during setup, then forget about the technical details.

Setting Up with Claude Desktop

Download the latest Claude Desktop application and locate the configuration file in your system's application data folder. On macOS, you'll find it at ~/Library/Application Support/Claude/config.json. Windows users should check %APPDATA%\Claude\config.json.

Open the configuration file and add the Outpacer MCP server details:

{
  "mcpServers": {
    "outpacer": {
      "command": "node",
      "args": ["/path/to/outpacer-mcp-server/index.js"],
      "env": {
        "OUTPACER_API_KEY": "opt_live_your_api_key_here"
      }
    }
  }
}

Installation Steps:

1. Install Node.js version 18 or higher on your system
2. Download the Outpacer MCP server from the official repository
3. Run npm install in the server directory
4. Update your Claude Desktop configuration with the server path
5. Restart Claude Desktop to load the new server connection

The MCP server typically takes 3-5 seconds to initialize when Claude Desktop starts. You'll see a green indicator in the bottom-left corner when the connection is active.

Setting Up with Claude Code

Claude Code requires a slightly different configuration approach since it runs in your development environment. Create a .claude-config file in your project root directory:

{
  "mcp_servers": {
    "outpacer": {
      "executable": "node",
      "args": ["./node_modules/@outpacer/mcp-server/dist/index.js"],
      "environment": {
        "OUTPACER_API_KEY": "opt_live_your_api_key_here",
        "LOG_LEVEL": "info"
      }
    }
  }
}

Install the MCP server package directly through npm:

npm install @outpacer/mcp-server

Development Environment Setup: Your development workflow benefits from environment variable management. Create a .env file for API key storage and reference it in your MCP configuration. This approach keeps credentials out of version control while maintaining easy server setup.

OUTPACER_API_KEY=opt_live_your_actual_key_here
OUTPACER_ENVIRONMENT=production
MCP_LOG_LEVEL=debug

The MCP server supports hot reloading during development. When you modify your configuration, the server automatically restarts without requiring a full Claude Code restart. This speeds up testing and configuration adjustments significantly.

Practical Example 1: Create a Website and Generate 5 Articles

This example demonstrates the complete workflow from website setup to bulk article generation. We'll create a new website in Outpacer, then generate 5 optimized articles for different target keywords.

REST API Approach

Step 1: Create the Website

import requests
import time

api_key = "opt_live_your_api_key_here"
headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json'
}

# Create new website
website_data = {
    "url": "https://example-blog.com",
    "name": "Example Blog",
    "industry": "Digital Marketing",
    "target_audience": "Small business owners",
    "content_tone": "professional"
}

response = requests.post(
    'https://api.outpacer.ai/v1/websites',
    headers=headers,
    json=website_data
)

website = response.json()
website_id = website['id']
print(f"Website created with ID: {website_id}")

Step 2: Generate 5 Articles Simultaneously

# Target keywords for article generation
keywords = [
    "email marketing best practices",
    "social media automation tools", 
    "content marketing ROI tracking",
    "SEO keyword research methods",
    "conversion rate optimization tips"
]

article_ids = []

for keyword in keywords:
    article_data = {
        "website_id": website_id,
        "target_keyword": keyword,
        "word_count": 1500,
        "content_type": "blog_post",
        "auto_optimize": True
    }
    
    response = requests.post(
        'https://api.outpacer.ai/v1/articles',
        headers=headers,
        json=article_data
    )
    
    article = response.json()
    article_ids.append(article['id'])
    print(f"Article created for '{keyword}': {article['id']}")
    
    # Rate limiting - wait 2 seconds between requests
    time.sleep(2)

print(f"Generated {len(article_ids)} articles successfully")

Step 3: Monitor Generation Progress

# Check generation status for all articles
def check_article_status(article_id):
    response = requests.get(
        f'https://api.outpacer.ai/v1/articles/{article_id}',
        headers=headers
    )
    return response.json()

# Wait for all articles to complete generation
completed_articles = []
max_wait_time = 300  # 5 minutes maximum wait

start_time = time.time()
while len(completed_articles) < len(article_ids):
    for article_id in article_ids:
        if article_id not in completed_articles:
            article_status = check_article_status(article_id)
            
            if article_status['status'] == 'completed':
                completed_articles.append(article_id)
                print(f"Article {article_id} completed generation")
            elif article_status['status'] == 'failed':
                print(f"Article {article_id} generation failed")
                completed_articles.append(article_id)  # Remove from waiting list
    
    if time.time() - start_time > max_wait_time:
        print("Timeout reached - some articles may still be generating")
        break
        
    time.sleep(10)  # Check every 10 seconds

print("Article generation process completed")

MCP Approach with Claude

Using the MCP server, the same workflow becomes a natural conversation:

You: Create a website for "https://example-blog.com" called "Example Blog" focused on digital marketing for small businesses, then generate 5 articles for these keywords: email marketing best practices, social media automation tools, content marketing ROI tracking, SEO keyword research methods, conversion rate optimization tips.

Claude: I'll help you create the website and generate those 5 articles. Let me start by setting up the website and then create each article.

[Claude creates the website and generates all 5 articles through MCP calls]

Website created successfully: Example Blog (ID: web_abc123)
Generated articles:
1. "Email Marketing Best Practices" - 1,487 words (ID: art_def456)
2. "Social Media Automation Tools" - 1,502 words (ID: art_ghi789)  
3. "Content Marketing ROI Tracking" - 1,445 words (ID: art_jkl012)
4. "SEO Keyword Research Methods" - 1,521 words (ID: art_mno345)
5. "Conversion Rate Optimization Tips" - 1,498 words (ID: art_pqr678)

All articles are optimized for their target keywords and ready for review.

The MCP approach eliminates error handling, status checking, and rate limiting concerns. Claude manages these technical details automatically while providing real-time progress updates.

Practical Example 2: Approve All Draft Articles

Bulk approval workflows save hours when you're managing multiple websites with dozens of draft articles. This example shows how to approve all articles that meet specific quality criteria.

REST API Implementation

# Get all draft articles across all websites
def get_draft_articles():
    response = requests.get(
        'https://api.outpacer.ai/v1/articles?status=draft',
        headers=headers
    )
    return response.json()['articles']

# Check article quality before approval
def meets_approval_criteria(article):
    # Get SEO score for quality assessment
    seo_response = requests.get(
        f'https://api.outpacer.ai/v1/articles/{article["id"]}/seo-score',
        headers=headers
    )
    seo_data = seo_response.json()
    
    criteria = {
        'min_word_count': 1000,
        'min_seo_score': 75,
        'required_sections': ['introduction', 'conclusion'],
        'max_keyword_density': 3.5
    }
    
    # Check word count
    if article['word_count'] < criteria['min_word_count']:
        return False, f"Word count too low: {article['word_count']}"
    
    # Check SEO score  
    if seo_data['overall_score'] < criteria['min_seo_score']:
        return False, f"SEO score too low: {seo_data['overall_score']}"
    
    # Check keyword density
    if seo_data['keyword_density'] > criteria['max_keyword_density']:
        return False, f"Keyword density too high: {seo_data['keyword_density']}%"
    
    return True, "Meets all criteria"

# Bulk approval process
draft_articles = get_draft_articles()
approved_count = 0
failed_approvals = []

for article in draft_articles:
    meets_criteria, reason = meets_approval_criteria(article)
    
    if meets_criteria:
        try:
            response = requests.post(
                f'https://api.outpacer.ai/v1/articles/{article["id"]}/approve',
                headers=headers,
                json={'approved_by': 'automated_system'}
            )
            
            if response.status_code == 200:
                approved_count += 1
                print(f"Approved: {article['title']}")
            else:
                failed_approvals.append(article['title'])
                
        except requests.exceptions.RequestException as e:
            failed_approvals.append(article['title'])
            print(f"Failed to approve {article['title']}: {str(e)}")
    else:
        print(f"Skipped {article['title']}: {reason}")
    
    time.sleep(1)  # Rate limiting

print(f"\nApproval Summary:")
print(f"Total articles processed: {len(draft_articles)}")
print(f"Successfully approved: {approved_count}")
print(f"Failed approvals: {len(failed_approvals)}")

Advanced Approval Logic

# Sophisticated approval criteria based on multiple factors
def advanced_approval_check(article_id):
    article_data = check_article_status(article_id)
    seo_response = requests.get(
        f'https://api.outpacer.ai/v1/articles/{article_id}/seo-score',
        headers=headers
    )
    seo_data = seo_response.json()
    
    # Multi-factor scoring system
    scores = {
        'content_quality': 0,
        'seo_optimization': 0,  
        'readability': 0,
        'brand_alignment': 0
    }
    
    # Content quality scoring
    if article_data['word_count'] >= 1500:
        scores['content_quality'] += 30
    elif article_data['word_count'] >= 1000:
        scores['content_quality'] += 20
    
    if len(article_data['headings']) >= 5:
        scores['content_quality'] += 20
        
    # SEO optimization scoring  
    scores['seo_optimization'] = min(seo_data['overall_score'], 40)
    
    # Readability scoring (Flesch reading ease)
    if seo_data['readability_score'] >= 60:
        scores['readability'] = 20
    elif seo_data['readability_score'] >= 40:
        scores['readability'] = 10
    
    # Brand alignment (custom keyword presence)
    brand_keywords = ['innovative', 'reliable', 'expert', 'trusted']
    brand_mentions = sum(1 for keyword in brand_keywords 
                        if keyword.lower() in article_data['content'].lower())
    scores['brand_alignment'] = min(brand_mentions * 5, 10)
    
    total_score = sum(scores.values())
    
    # Require minimum 70/100 for approval
    return total_score >= 70, total_score, scores

# Apply advanced approval to all drafts
for article in draft_articles:
    should_approve, total_score, detailed_scores = advanced_approval_check(article['id'])
    
    if should_approve:
        # Approve and add approval note with score
        approval_data = {
            'approved_by': 'ai_agent',
            'approval_score': total_score,
            'score_breakdown': detailed_scores,
            'approval_timestamp': time.time()
        }
        
        requests.post(
            f'https://api.outpacer.ai/v1/articles/{article["id"]}/approve',
            headers=headers,
            json=approval_data
        )
        print(f"Approved {article['title']} with score {total_score}/100")
    else:
        print(f"Rejected {article['title']} - Score: {total_score}/100")

Practical Example 3: Run Competitor Research

Competitor research automation helps you identify content gaps and ranking opportunities across multiple competitor domains. This example monitors 5 competitors and generates actionable insights.

Comprehensive Competitor Analysis

# List of competitors to analyze
competitors = [
    "competitor1.com",
    "competitor2.com", 
    "competitor3.com",
    "competitor4.com",
    "competitor5.com"
]

def add_competitor(domain):
    competitor_data = {
        "domain": domain,
        "tracking_keywords": True,
        "content_analysis": True,
        "backlink_monitoring": True
    }
    
    response = requests.post(
        'https://api.outpacer.ai/v1/competitors',
        headers=headers,
        json=competitor_data
    )
    
    return response.json()

def analyze_competitor(competitor_id):
    # Run comprehensive analysis
    analysis_response = requests.post(
        f'https://api.outpacer.ai/v1/competitors/{competitor_id}/analyze',
        headers=headers,
        json={"analysis_type": "full"}
    )
    
    # Get content gaps
    gaps_response = requests.get(
        f'https://api.outpacer.ai/v1/competitors/{competitor_id}/content-gaps',
        headers=headers
    )
    
    # Get current rankings
    rankings_response = requests.get(
        f'https://api.outpacer.ai/v1/competitors/{competitor_id}/rankings',
        headers=headers
    )
    
    return {
        'analysis': analysis_response.json(),
        'content_gaps': gaps_response.json(), 
        'rankings': rankings_response.json()
    }

# Process all competitors
competitor_insights = {}

for domain in competitors:
    print(f"Adding competitor: {domain}")
    competitor = add_competitor(domain)
    competitor_id = competitor['id']
    
    # Wait for competitor data to be collected
    time.sleep(30)
    
    print(f"Analyzing {domain}...")
    insights = analyze_competitor(competitor_id)
    competitor_insights[domain] = insights
    
    print(f"Found {len(insights['content_gaps']['opportunities'])} content opportunities")

# Generate opportunity report
def generate_opportunity_report(insights_data):
    all_opportunities = []
    
    for domain, insights in insights_data.items():
        for opportunity in insights['content_gaps']['opportunities']:
            all_opportunities.append({
                'competitor': domain,
                'keyword': opportunity['keyword'],
                'search_volume': opportunity['monthly_searches'],
                'difficulty': opportunity['keyword_difficulty'],
                'competitor_rank': opportunity['current_position'],
                'content_type': opportunity['suggested_content_type'],
                'opportunity_score': opportunity['opportunity_score']
            })
    
    # Sort by opportunity score (highest first)
    all_opportunities.sort(key=lambda x: x['opportunity_score'], reverse=True)
    
    return all_opportunities

opportunities = generate_opportunity_report(competitor_insights)

# Display top 10 opportunities
print("\nTop 10 Content Opportunities:")
print("-" * 80)
for i, opp in enumerate(opportunities[:10], 1):
    print(f"{i}. {opp['keyword']}")
    print(f"   Volume: {opp['search_volume']} | Difficulty: {opp['difficulty']}")
    print(f"   Competitor: {opp['competitor']} (Rank: {opp['competitor_rank']})")
    print(f"   Score: {opp['opportunity_score']}/100")
    print()

Automated Content Gap Exploitation

# Automatically create content plans for top opportunities
def create_content_plan_from_opportunities(opportunities, max_articles=10):
    top_opportunities = opportunities[:max_articles]
    
    keywords_for_plan = [opp['keyword'] for opp in top_opportunities]
    
    content_plan_data = {
        "name": f"Competitor Gap Exploitation - {time.strftime('%Y-%m-%d')}",
        "target_keywords": keywords_for_plan,
        "articles_per_keyword": 1,
        "word_count_range": [1200, 2000],
        "content_type": "blog_post",
        "auto_optimize": True
    }
    
    response = requests.post(
        'https://api.outpacer.ai/v1/content-plans',
        headers=headers,
        json=content_plan_data
    )
    
    return response.json()

# Execute content plan creation
if len(opportunities) > 0:
    content_plan = create_content_plan_from_opportunities(opportunities)
    print(f"Created content plan: {content_plan['name']}")
    print(f"Targeting {len(content_plan['target_keywords'])} opportunity keywords")
    
    # Execute the content plan
    execution_response = requests.post(
        f'https://api.outpacer.ai/v1/content-plans/{content_plan["id"]}/execute',
        headers=headers
    )
    
    if execution_response.status_code == 200:
        print("Content plan execution started successfully")
    else:
        print("Failed to execute content plan")

# Set up ongoing competitor monitoring
def setup_competitor_alerts():
    alert_config = {
        "alert_type": "ranking_changes",
        "threshold": 3,  # Alert when competitor moves up 3+ positions
        "frequency": "daily",
        "notification_webhook": "https://your-webhook-url.com/competitor-alerts"
    }
    
    for domain in competitors:
        requests.post(
            f'https://api.outpacer.ai/v1/competitors/{domain}/alerts',
            headers=headers,
            json=alert_config
        )
    
    print("Competitor monitoring alerts configured")

setup_competitor_alerts()

Understanding the competitive landscape through automated analysis gives you a significant advantage. These scripts run daily to identify new opportunities as they emerge, ensuring you never miss a chance to outrank competitors with superior content.

Your AI agent can expand this basic framework to include social media monitoring, backlink gap analysis, and content freshness tracking. The key lies in building workflows that continuously feed your content strategy with data-driven insights rather than relying on manual competitor research.

Best Practices and Rate Limiting

API rate limiting protects both your account and Outpacer's infrastructure from overload. The current limit sits at 1000 requests per hour, with a burst allowance of 100 requests in any 5-minute window. Your applications should implement exponential backoff when hitting these limits.

Rate Limiting Implementation:

import time
from functools import wraps

def rate_limit(max_calls_per_minute=50):
    def decorator(func):
        calls = []
        
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            # Remove calls older than 1 minute
            calls[:] = [call_time for call_time in calls if now - call_time < 60]
            
            if len(calls) >= max_calls_per_minute:
                sleep_time = 60 - (now - calls[0])
                print(f"Rate limit reached. Sleeping for {sleep_time:.2f} seconds")
                time.sleep(sleep_time)
                calls.clear()
            
            calls.append(now)
            return func(*args, **kwargs)
        
        return wrapper
    return decorator

@rate_limit(max_calls_per_minute=45)  # Stay under the limit
def make_outpacer_request(endpoint, method='GET', data=None):
    # Your API request logic here
    pass

Error Handling Best Practices: Always implement retry logic for transient failures. Network timeouts, temporary server issues, and rate limit exceeded responses should trigger automatic retries with increasing delays between attempts.

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_retries():
    session = requests.Session()
    
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
        allowed_methods=["HEAD", "GET", "OPTIONS", "POST", "PUT", "DELETE"]
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

session = create_session_with_retries()

Monitor your API usage through the Outpacer dashboard to avoid unexpected rate limit issues. The usage meter updates every 15 minutes and shows both current hour consumption and historical patterns.

Resource Management: Close HTTP connections properly and reuse session objects when making multiple requests. Creating new connections for every API call wastes resources and slows down your automation scripts.

Large batch operations benefit from request chunking—process 20-50 items at a time rather than attempting to handle hundreds simultaneously. This approach reduces memory usage and provides better error recovery when individual requests fail.

Troubleshooting Common Issues

Authentication Failures: Double-check your API key format and ensure you're using the correct environment (test vs. production). Keys beginning with opt_test_ only work in sandbox mode, while production requires opt_live_ keys. Copy the key directly from your account settings to avoid transcription errors.

MCP Connection Problems: Verify your Node.js version meets the minimum requirement of 18.0 or higher. Older versions lack required crypto functions that the MCP server depends on. If Claude Desktop shows a red connection indicator, check the console logs for specific error messages.

The most common MCP issue involves incorrect file paths in the configuration. Use absolute paths rather than relative ones to avoid directory resolution problems:

{
  "mcpServers": {
    "outpacer": {
      "command": "node",
      "args": ["/Users/your-username/outpacer-mcp-server/index.js"],
      "env": {
        "OUTPACER_API_KEY": "opt_live_your_key_here"
      }
    }
  }
}

Timeout and Performance Issues: Article generation typically completes within 2-3 minutes, but complex requests with extensive research requirements may take up to 10 minutes. Implement timeout handling with appropriate wait periods:

def wait_for_completion(article_id, max_wait=600):  # 10 minutes max
    start_time = time.time()
    
    while time.time() - start_time < max_wait:
        status = check_article_status(article_id)
        
        if status['status'] in ['completed', 'failed']:
            return status
            
        time.sleep(30)  # Check every 30 seconds
    
    return {'status': 'timeout', 'message': 'Generation exceeded maximum wait time'}

Webhook Integration Issues: Webhook endpoints must respond with HTTP 200 status codes within 10 seconds. Slower responses trigger retry attempts that can overwhelm your server. Implement async processing for webhook payloads