SITERANK AI — AI-Powered Website Competitor Analyzer

Transform your website from underperformer to industry leader with AI-powered competitive intelligence

Problem • Solution • Features • RankBot • Implement • Trust Model • Architecture • Business Model • Getting Started • API Docs • Roadmap

📋 Table of Contents

Problem Statement
Solution Overview
Target Market & ICPs
Use Cases
Features
RankBot — MCP-Powered AI Chatbot
One-Click AI Implementation Engine
Trust & Ownership Model
Solution Architecture
Technology Stack
Integrations
Business Model
API Documentation
Getting Started
Roadmap

🎯 Problem Statement

The Challenge

In today's digital landscape, businesses face critical challenges in maintaining a competitive web presence:

Visibility Gap — 93% of online experiences begin with a search engine, yet most businesses don't know why competitors rank higher.
Technical Complexity — Website optimization requires expertise in SEO, performance, content strategy, and UX — skills most businesses lack in-house.
Blind Competition — Companies invest in websites without understanding their competitive position or what specific improvements will yield the best ROI.
Information Overload — Existing tools provide raw data without actionable insights, leaving users overwhelmed and paralyzed.
Cost Barrier — Enterprise SEO tools cost $500–$2,000/month, putting competitive intelligence out of reach for SMBs.

The Pain Points

Stakeholder	Pain Point
Small Business Owners	"I know my competitors rank higher, but I don't know why or how to fix it"
Marketing Managers	"I need to justify SEO budget but can't quantify the gap with competitors"
Web Developers	"Clients ask for 'better SEO' but I need specific, prioritized action items"
Digital Agencies	"Creating competitor analyses manually takes 8+ hours per client"
Startup Founders	"I can't afford enterprise tools but need competitive intelligence to survive"

💡 Solution Overview

SITERANK AI: Your AI-Powered Competitive Intelligence Platform

SITERANK AI transforms complex website analysis into actionable optimization blueprints. We don't just show you data — we tell you exactly what to fix, in what order, and provide the code to do it.

┌──────────────────────────────────────────────────────────────────┐
│                                                                  │
│   INPUT:   Your website URL + (optional) competitor URLs         │
│                              ↓                                   │
│   PROCESS: AI-powered multi-dimensional analysis                 │
│                              ↓                                   │
│   OUTPUT:  Prioritized action plan with copy-paste fixes         │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

Key Differentiators

Traditional Tools	SITERANK AI
Show raw metrics	Provide actionable fixes
Require expertise to interpret	AI explains in plain English
Manual competitor research	Auto-detect competitors
Generic recommendations	Personalized optimization blueprint
Expensive subscriptions	Free tier available
Data dumps	Prioritized action plans

👥 Target Market & ICPs

Ideal Customer Profiles

🏪 ICP 1: Small Business Owner (Primary)

Demographics: Owner of local business, 1–50 employees
Technographics: Basic website (WordPress, Wix, Squarespace)
Budget: $0–$200/month for marketing tools
Goal: Rank higher than local competitors, get more leads
Quote: "I just want to know what's wrong and how to fix it"

📈 ICP 2: Marketing Manager (Secondary)

Demographics: Marketing lead at SMB/mid-market company
Technographics: Uses multiple marketing tools, data-driven
Budget: $200–$1,000/month for SEO tools
Goal: Outperform competitors, justify marketing spend
Quote: "I need competitive intelligence I can present to leadership"

💻 ICP 3: Freelance Web Developer / Agency

Demographics: Freelancer or small agency (1–10 people)
Budget: $100–$500/month per tool
Goal: Deliver more value to clients efficiently
Quote: "I need to audit client sites faster without sacrificing quality"

🚀 ICP 4: Startup Founder

Demographics: Early-stage startup, limited resources
Budget: $0–$100/month initially
Goal: Understand market position, find quick wins
Quote: "I need enterprise-level insights on a startup budget"

Market Size

Segment	TAM	SAM	SOM (Year 1)
Global SEO Tools Market	$80B	$5B	$500K
SMB Digital Marketing	$200B	$10B	$1M
Web Development Services	$60B	$2B	$200K

🔄 Use Cases

Use Case 1: Website Health Check

Actor:   Small Business Owner
Trigger: Noticed declining website traffic

Flow:
  1. User enters their website URL
  2. System auto-detects top 3 competitors
  3. Analysis runs (SEO, Speed, Content, UX)
  4. User receives optimization blueprint
  5. User implements "Critical Fixes" section

Outcome: 20–40% improvement in target metrics within 30 days

Use Case 2: Competitive Gap Analysis

Actor:   Marketing Manager
Trigger: Quarterly competitive review

Flow:
  1. User enters company site + 5 competitor URLs
  2. System generates comparative scorecards
  3. AI identifies specific gaps and opportunities
  4. User exports PDF report for stakeholders
  5. Team prioritizes backlog based on findings

Outcome: Data-driven marketing strategy with clear priorities

Use Case 3: Client Website Audit

Actor:   Web Developer / Agency
Trigger: New client onboarding

Flow:
  1. Developer enters client's website URL
  2. System performs comprehensive analysis
  3. Developer reviews AI-generated fixes
  4. Developer copies code snippets for implementation
  5. Re-runs analysis to verify improvements

Outcome: Professional audit delivered in 15 minutes vs 8 hours

Use Case 4: SEO Quick Fix

Actor:   Any User
Trigger: Need to fix a specific SEO issue

Flow:
  1. User navigates to SEO Analysis page
  2. Enters website URL
  3. System identifies meta tag issues
  4. AI generates optimized title/description
  5. User copies fix with one click

Outcome: SEO improvements implemented in under 5 minutes

Use Case 5: Performance Optimization

Actor:   Developer / Technical User
Trigger: Slow website complaint

Flow:
  1. User navigates to Speed Metrics page
  2. System analyzes load time, page size, resources
  3. AI identifies optimization opportunities
  4. System provides code snippets (lazy loading, compression)
  5. User implements and re-tests

Outcome: 40–60% improvement in page load speed

Use Case 6: Content Strategy Development

Actor:   Content Marketer
Trigger: Need blog topic ideas

Flow:
  1. User navigates to Content Score page
  2. Enters website URL
  3. System analyzes existing content
  4. AI generates 3 blog topic ideas based on gaps
  5. User uses ideas to create content calendar

Outcome: Content strategy aligned with SEO opportunities

✨ Features

🚀 Optimize My Site (Flagship Feature)

The one-click comprehensive analysis that delivers a complete optimization blueprint.

Auto-detects your top competitors
Analyzes 50+ ranking factors
Generates prioritized action plan with a 30-day strategy
Output: Critical Fixes → Quick Wins → Strategic Improvements → Competitor Insights

🔍 SEO Analysis Engine

Meta tag analysis with AI-generated fixes
Heading structure audit (H1–H6)
Schema.org markup generator
Internal linking recommendations
Keyword optimization suggestions

⚡ Speed Metrics Analyzer

Load time measurement & page size analysis
Image optimization detection
Caching recommendations
Code minification suggestions
Core Web Vitals estimation

📝 Content Score Engine

Word count and depth analysis
Readability scoring & thin content detection
AI-generated blog topic ideas
Keyword gap identification
FAQ section recommendations

📊 Competitor Comparison

Multi-site score comparison with visual charts
Gap identification & opportunity highlighting
Exportable reports

🤖 AI Chat Assistant (Powered by DeepSeek)

Natural language support — ask anything about your site
Context-aware optimization advice
Available 24/7

🤖 RankBot — MCP-Powered AI Chatbot

RankBot is not a FAQ bot. It is a tool-calling AI agent built on the Model Context Protocol — it understands natural language, decides which backend tools to invoke, executes them with real data, and synthesizes the results into specific, actionable advice.

How It Works

User: "Analyze my site example.com vs competitor hubspot.com"
              ↓
    RankBot decides which tools to call
              ↓
   🔧 Tool Call 1: analyze_seo("example.com")
   🔧 Tool Call 2: analyze_seo("hubspot.com")
   🔧 Tool Call 3: compare_competitors(...)
              ↓
    RankBot reads live results
              ↓
    RankBot responds with real scores + specific action plan

The 6 MCP Tools

Tool	What It Does	Triggered When User Says…
`analyze_seo(url)`	Checks meta tags, headings, schema, sitemap	"analyze my SEO" / "check my site"
`analyze_speed(url)`	Returns LCP, CLS, FID, page size	"why is my site slow" / "speed score"
`analyze_content(url)`	Word count, readability, E-E-A-T	"improve my content" / "content score"
`check_ux(url)`	Mobile-friendliness, WCAG accessibility	"UX issues" / "mobile problems"
`compare_competitors(url, rivals[])`	Side-by-side gap analysis	"compare with…" / "beat competitor"
`generate_action_plan(url, scores)`	Prioritized fix list with effort + impact	"what should I fix first" / "action plan"

Agent Architecture

┌─────────────────────────────────────┐
│         CHAT UI (Frontend)          │  ← User types; sees live tool status
├─────────────────────────────────────┤
│      AI AGENT (Claude / GPT)        │  ← Understands intent, picks tools
├─────────────────────────────────────┤
│         MCP TOOL LAYER              │  ← analyze_seo, analyze_speed, compare…
│   (calls your real FastAPI routes)  │  ← Live data — never mocked
└─────────────────────────────────────┘

MCP Server Setup

The MCP server wraps the existing FastAPI app and exposes every route as a callable tool — no rewriting needed.

# mcpserver.py
from fastmcp import FastMCP
from server import app

mcp = FastMCP.from_fastapi(
    app=app,
    name="SITERANK AI Server",
)

if __name__ == "__main__":
    mcp.run(
        transport="streamable-http",
        host="0.0.0.0",
        port=8001
    )

FastAPI Routes → MCP Tools (auto-mapped)

FastAPI Route	MCP Tool	Claude Calls It When…
`POST /analyze/seo`	`analyze_seo(url)`	User says "check my SEO"
`POST /analyze/speed`	`analyze_speed(url)`	User says "why is site slow"
`POST /analyze/content`	`analyze_content(url)`	User says "improve my content"
`POST /compare`	`compare_competitors(url, rivals)`	User says "compare with X"
`POST /action-plan`	`generate_action_plan(url)`	User says "what do I fix first"

Example Conversation

👤 User: "My speed score is 72. How do I fix it?"

🔧 RankBot calls: analyze_speed("example.com")
   Tool returns → LCP: 3.2s, render-blocking JS: 3 files,
                  no WebP images, no caching headers

🤖 RankBot responds:
   "Your main bottleneck is a 3.2s LCP — above the 2.5s threshold.
    Priority fixes:
    1. ⚡ Defer 3 render-blocking scripts → +8 speed pts (1 hr work)
    2. 🖼  Convert images to WebP         → +5 speed pts (1 hr work)
    3. 📦 Add cache-control headers       → +4 speed pts (30 min work)
    Want me to generate the exact code for each?"

UX Details That Make It Feel Powerful

Live tool call indicators — displays 🔧 Running: analyze_seo("example.com")... so users see work happening
Score cards in chat — renders real score widgets directly inside the conversation
Quick prompt chips — one-click buttons: Analyze my site, Compare competitors, Fix my speed
Follow-up suggestions — after every result, RankBot recommends the next logical action

Chat API Bridge

# Add to server.py — routes frontend → Claude with tool loop

@app.post("/api/chat")
async def chat(req: ChatRequest):
    messages = req.history + [{"role": "user", "content": req.message}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-5-20251101",
            max_tokens=2048,
            system="""You are RankBot, SiteRank AI's expert assistant.
When users mention a URL, ALWAYS call the appropriate tool first.
Never guess scores — always use tools to get real data.""",
            tools=MCP_TOOLS,
            messages=messages
        )

        if response.stop_reason == "end_turn":
            text = next(b.text for b in response.content if b.type == "text")
            return {"reply": text}

        # Process tool calls → call real FastAPI endpoints → feed results back
        tool_results = await process_tool_calls(response.content)
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})

⚡ One-Click AI Implementation Engine

SITERANK AI goes beyond reporting. When an issue is found, users can click "Implement Now" and the AI generates complete, production-ready fix code — not suggestions, not advice, actual working code to paste.

The Shift: Reporting → Doing

OLD:  User → Analyze URL → See problems → Fix manually (hours)

NEW:  User → Analyze URL → See problems → Click "Implement Now"
             → AI generates exact fix code → Copy → Done (minutes)

What Each Feature Implements

🔍 SEO — Auto-Fix

Issue Detected	AI Output
Title tag too long / missing	Optimized `<title>` tag (50–60 chars, keyword-rich)
Meta description missing	Written meta description from page content with CTA
No H1 tag	Suggested H1 with target keyword inserted
Images missing alt text	Descriptive alt text generated per image
No schema markup	Complete JSON-LD block (Organization, WebPage, FAQ)
Canonical tag missing	Correct canonical HTML tag
No sitemap	`sitemap.xml` generated from crawled URLs

⚡ Speed — Auto-Fix

Issue Detected	AI Output
Render-blocking JS	`<script>` tags rewritten with `defer`/`async`
Uncompressed images	`<picture>` + `srcset` WebP code
Missing cache headers	`.htaccess` or `nginx.conf` cache config
No lazy loading	`loading="lazy"` added to all `<img>` tags
Missing gzip config	Server compression configuration block
No LCP image preload	`<link rel="preload">` tag generated

📝 Content — Auto-Fix

Issue Detected	AI Output
Title not keyword-optimized	Rewrites title with target keyword
Thin content (<500 words)	AI-written expansion paragraphs
Low readability score	Complex paragraphs rewritten clearly
No FAQ section	FAQ section with JSON-LD schema generated
Missing internal links	Anchor text + target URL suggestions inserted
Weak CTA	Call-to-action copy rewritten
No conclusion	Conclusion paragraph written

Implementation API Endpoints

POST /api/implement/seo      → generates SEO fix code
POST /api/implement/speed    → generates speed fix code  
POST /api/implement/content  → rewrites content sections

Example Response Structure

{
  "suggestion_id": "missing_meta_description",
  "title": "Add Meta Description",
  "status": "implemented",
  "implementations": [
    {
      "file": "index.html",
      "placement": "Inside <head>",
      "before": null,
      "after": "<meta name='description' content='AI-powered SEO tool that analyzes your website and outranks competitors in 30 days.' />",
      "action_label": "Copy & Paste into <head>",
      "estimated_impact": "+8 SEO points, +15% CTR"
    }
  ]
}

UI Flow

STEP 1 — Analysis View
┌─────────────────────────────────────────┐
│  SEO Score: 65/100                      │
│                                         │
│  ✕ Missing meta description             │
│  ✕ No schema markup       [⚡ FIX ALL]  │
│  ✕ Title tag too long                   │
└─────────────────────────────────────────┘

STEP 2 — AI Generating Fixes
┌─────────────────────────────────────────┐
│  🤖 AI is generating fixes...           │
│  ✓ Analyzing meta description...        │
│  ✓ Writing optimized title...           │
│  ✓ Generating schema markup...          │
└─────────────────────────────────────────┘

STEP 3 — Ready-to-Use Code
┌─────────────────────────────────────────┐
│  ✓ Meta Description Fixed               │
│  📄 Paste in: index.html → <head>       │
│  ┌──────────────────────────────────┐   │
│  │ <meta name="description"         │   │
│  │   content="AI-powered SEO tool…" │   │
│  └──────────────────────────────────┘   │
│  [📋 Copy Code]  [⬇ Download Patch]     │
└─────────────────────────────────────────┘

Three Delivery Modes

Mode	Description	Status
Copy-Paste	Syntax-highlighted code block + one-click copy	✅ Built
Patch File	Download `.patch` → apply with `git apply`	🔄 In Progress
GitHub PR	OAuth → AI opens pull request directly in repo	📋 Planned

🔐 Trust & Ownership Model

SITERANK AI is an audit and fix-generation tool — it reads publicly available website data and generates recommendations. It never pushes changes to a website without explicit owner authorization.

The Three User Roles

┌─────────────────────────────────────────────┐
│  Step 1: Who is this site?                  │
│                                             │
│  ○ This is MY website                       │
│  ○ This is a CLIENT website                 │
│  ○ This is a COMPETITOR website             │
└─────────────────────────────────────────────┘
         ↓              ↓               ↓
   Fix code +     Export report +   Intelligence
   CMS connect    fix package for   only — no
   option         the client        fix UI shown

User Type	What They Need	What SITERANK AI Provides
Website Owner	Fix code to paste themselves	Code snippets + optional CMS connect (with OAuth)
SEO Agency	Client report + fix recommendations	PDF report + fix package to send to client's dev team
Competitor Researcher	Intelligence only	Competitive gap analysis — no fix UI shown

Ownership Verification (for Direct Apply)

For users who want AI to apply fixes directly via CMS, ownership is verified the same way as Google Search Console — DNS TXT record or file upload:

1. User enters their URL
2. SITERANK AI: "Add this TXT record to your DNS
                 or upload this file to your root directory"
3. Once verified → CMS Connect unlocked
4. AI applies fixes via WordPress / Shopify / Webflow API

What's Legal & What's Not

✅ LEGAL — what SITERANK AI does:
   Analyze any public website (same as Google's crawler)
   Report findings and generate fix recommendations
   Apply fixes via owner-authorized CMS API

✅ LEGAL — the agency model:
   Ahrefs, SEMrush, Moz all analyze public sites
   Report findings, suggest fixes, client applies them

❌ NOT DONE — would be unauthorized:
   Pushing code changes to websites without owner consent

The Real Value Proposition

WITHOUT SITERANK AI:
  Developer: 4 hrs manual audit + 2 hrs writing fixes + 1 hr client report
  = 7 hours work

WITH SITERANK AI:
  Paste URL → 30 seconds
  Get full audit + exact fix code + client-ready PDF
  = 30 seconds

The AI eliminates the research and writing time. The owner always applies the fix. That's the correct, legal, trusted model.

🏗 Solution Architecture

System Architecture

┌────────────────────────────────────────────────────────────────────────┐
│                              FRONTEND                                   │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌────────────┐       │
│  │  Landing   │  │ Dashboard  │  │  Analysis  │  │  Feature   │       │
│  │   Page     │  │   Page     │  │   Pages    │  │   Pages    │       │
│  └────────────┘  └────────────┘  └────────────┘  └────────────┘       │
│                           React + TailwindCSS + Shadcn UI               │
└──────────────────────────────────┬─────────────────────────────────────┘
                                   │ HTTPS / REST API
                                   ▼
┌────────────────────────────────────────────────────────────────────────┐
│                               BACKEND                                   │
│  ┌──────────────────────────────────────────────────────────────────┐  │
│  │                         FastAPI Server                            │  │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐           │  │
│  │  │  Auth    │ │ Scraper  │ │ Analyzer │ │    AI    │           │  │
│  │  │ Module   │ │ Module   │ │ Module   │ │  Engine  │           │  │
│  │  └──────────┘ └──────────┘ └──────────┘ └──────────┘           │  │
│  └──────────────────────────────────────────────────────────────────┘  │
│                            Python 3.11                                  │
└──────────────────────────────────┬─────────────────────────────────────┘
                                   │
                    ┌──────────────┼──────────────┐
                    ▼              ▼              ▼
            ┌──────────┐  ┌──────────┐  ┌──────────┐
            │ MongoDB  │  │  NVIDIA  │  │  OpenAI  │
            │ Database │  │ DeepSeek │  │  GPT-5.2 │
            └──────────┘  └──────────┘  └──────────┘

Data Flow

User Request → API Gateway → Authentication → Route Handler
                                                    │
                    ┌───────────────────────────────┘
                    ▼
            ┌───────────────┐
            │  Web Scraper  │ ──→ Target Website
            └───────────────┘
                    │
                    ▼
            ┌───────────────┐
            │   Analyzer    │ ──→ Score Calculation
            └───────────────┘
                    │
                    ▼
            ┌───────────────┐
            │   AI Engine   │ ──→ NVIDIA DeepSeek / OpenAI
            └───────────────┘
                    │
                    ▼
            ┌───────────────┐
            │   Response    │ ──→ User Interface
            └───────────────┘

Frontend Structure

/frontend/src/
├── components/
│   ├── ChatBot.js          # AI chat assistant
│   ├── Navbar.js           # Navigation with dropdowns
│   ├── Logo.js             # Brand logo component
│   └── ui/                 # Shadcn UI components
├── pages/
│   ├── LandingPage.js      # Marketing homepage
│   ├── DashboardPage.js    # User dashboard
│   ├── AnalyzePage.js      # New analysis form
│   ├── OptimizePage.js     # Optimization blueprint
│   ├── SEOAnalysisPage.js  # SEO engine
│   ├── SpeedMetricsPage.js # Speed analyzer
│   └── ContentScorePage.js # Content engine
└── context/
    └── AuthContext.js      # Authentication state

Backend Structure

/backend/
├── server.py               # Main FastAPI application
├── auth.py                 # JWT authentication
├── scraper.py              # Website scraping engine
├── analyzer.py             # Score calculation
├── llm_engine.py           # OpenAI integration
├── optimization_engine.py  # Blueprint generator
├── seo_analyzer.py         # SEO analysis module
├── speed_analyzer.py       # Performance analysis
├── content_analyzer.py     # Content analysis
├── competitor_detector.py  # Auto-detect competitors
├── mcpserver.py            # MCP Server for AI agents
└── models.py               # Pydantic models

🛠 Technology Stack

Frontend

Technology	Purpose	Version
	UI Framework	18.x
	Styling	3.x
Shadcn UI	Component Library	Latest
React Router	Navigation	6.x
Recharts	Data Visualization	2.x
Lucide React	Icons	Latest

Backend

Technology	Purpose	Version
	Runtime	3.11
	API Framework	0.110.x
Motor	Async MongoDB Driver	3.x
Pydantic	Data Validation	2.x
BeautifulSoup	Web Scraping	4.x
HTTPX	HTTP Client	0.28.x
FastMCP	MCP Server	2.14.x

Database & AI/ML

Technology	Purpose
	Primary Database
NVIDIA DeepSeek v3.2	AI Chat Assistant
OpenAI GPT-5.2	Content Generation & SEO Suggestions
Emergent LLM	Unified AI Provider Access

Infrastructure

Technology	Purpose
Emergent Platform	Hosting & Deployment
Nginx	Reverse Proxy
Supervisor	Process Management

🔌 Integrations

Active Integrations

1. NVIDIA DeepSeek API

Powers the AI Chat Assistant with context-aware, conversational support.

NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1"
MODEL = "deepseek-ai/deepseek-v3.2"

2. OpenAI GPT-5.2

Drives all optimization suggestions, content recommendations, and competitor analysis insights.

3. Emergent LLM Gateway

Unified access layer supporting OpenAI, Anthropic Claude, and Google Gemini.

4. MCP Server (Model Context Protocol)

Exposes the entire SITERANK AI API as tools consumable by any AI agent.

# mcpserver.py
from fastmcp import FastMCP
from server import app

mcp = FastMCP.from_fastapi(
    app=app,
    name="SITERANK AI Server",
)

Future Integrations

Integration	Purpose	Priority
Google Search Console	Real ranking data	P1
Google Analytics	Traffic insights	P1
Stripe	Payment processing	P1
SendGrid	Email notifications	P2
Slack	Team notifications	P2
Zapier	Workflow automation	P3

💰 Business Model

Freemium SaaS Tiers

Tier	Price	Highlights
Free	$0/mo	5 analyses/month, all core features
Pro	$29/mo	Unlimited analyses, PDF export, full AI chat
Agency	$99/mo	Multi-client dashboard, white-label, API access
Enterprise	Custom	Custom integrations, SLA, dedicated support

Feature Matrix

Feature	Free	Pro	Agency	Enterprise
Website Analyses	5/mo	∞	∞	∞
Competitor Detection	✅	✅	✅	✅
Optimization Blueprint	✅	✅	✅	✅
SEO / Speed / Content Analysis	✅	✅	✅	✅
PDF Export	❌	✅	✅	✅
AI Chat Support	Limited	✅	✅	✅
Multi-client Dashboard	❌	❌	✅	✅
White-label Reports	❌	❌	✅	✅
API Access	❌	❌	✅	✅
Custom Integrations	❌	❌	❌	✅
SLA + Dedicated Support	❌	❌	❌	✅

Unit Economics

Customer Acquisition Cost (CAC) :  $50
Average Revenue Per User (ARPU)  :  $35/month
Lifetime Value (LTV)             :  $420 (12-month avg)
LTV : CAC Ratio                  :  8.4×
Gross Margin                     :  85%

📚 API Documentation

Authentication

All protected endpoints require a JWT Bearer token in the Authorization header:

Authorization: Bearer <your_token>

Endpoint Reference

Auth

Method	Endpoint	Description
`POST`	`/api/auth/register`	Register a new user
`POST`	`/api/auth/login`	Login and receive JWT
`GET`	`/api/auth/me`	Get current user profile

Analyses

Method	Endpoint	Description
`POST`	`/api/analyses`	Create a new analysis
`GET`	`/api/analyses`	List all user analyses
`GET`	`/api/analyses/{id}`	Get a specific analysis
`DELETE`	`/api/analyses/{id}`	Delete an analysis
`GET`	`/api/analyses/{id}/report`	Download PDF report

Feature Endpoints

Method	Endpoint	Description
`POST`	`/api/optimize`	Generate optimization blueprint
`POST`	`/api/seo/analyze`	Run SEO analysis
`POST`	`/api/speed/analyze`	Run speed analysis
`POST`	`/api/content/analyze`	Run content analysis
`POST`	`/api/competitors/detect`	Auto-detect competitors
`POST`	`/api/chatbot`	Chat with AI assistant (legacy)
`GET`	`/api/dashboard/stats`	Dashboard statistics
`GET`	`/api/health`	Health check

RankBot Chat Endpoint

Method	Endpoint	Description
`POST`	`/api/chat`	MCP-powered agentic chat with tool-use loop

Request body:

{
  "message": "Analyze https://example.com and compare with hubspot.com",
  "history": []
}

Response:

{
  "reply": "Your site scores 81/100 vs HubSpot's 94/100. Main gap is schema markup…",
  "tool_calls": ["analyze_seo", "compare_competitors"]
}

One-Click Implementation Endpoints

Method	Endpoint	Description
`POST`	`/api/implement/seo`	Generate complete SEO fix code
`POST`	`/api/implement/speed`	Generate complete speed fix code
`POST`	`/api/implement/content`	Rewrite content sections with AI