TruIntel Platform Documentation

TruIntel is an AI Engine Optimization (AEO) platform that helps businesses monitor, analyze, and improve how AI assistants perceive and recommend their brand. Traditional SEO focuses on Google — AEO focuses on ChatGPT, Claude, Gemini, Perplexity, and Google AI Overview.

Get up and running with TruIntel in under 5 minutes. Follow these steps to start monitoring your AI visibility.

TruIntel supports multiple authentication methods to keep your account secure.

After creating your account, TruIntel guides you through a multi-step onboarding process to set up your brand monitoring.

TruIntel supports multi-user organizations with role-based access control.

Invite team members by email from Settings → Team. They will receive an invitation link that expires after 7 days. You can also switch between organizations if you belong to multiple.

AI Visibility Monitoring is TruIntel's core feature. It tracks how AI platforms — ChatGPT, Claude, Gemini, Perplexity, and Google AI Overview — mention, recommend, and rank your brand when users ask questions relevant to your industry.

Your Visibility Score (0–100) is a composite metric calculated from four weighted components:

TruIntel monitors your brand across 5 major AI platforms simultaneously. Each platform is queried with your tracking queries to check for brand mentions, positioning, and sentiment.

ChatGPT

OpenAI GPT-5.2 via Responses API with web search enabled. The most widely used AI assistant.

Claude

Anthropic Claude Sonnet 4.5 via Messages API with web search tool. Known for nuanced, balanced responses.

Gemini

Google Gemini 3 Flash with Google Search grounding. Integrated into Google's ecosystem.

Perplexity

Perplexity Sonar with built-in source citations. A search-first AI with real-time web access.

Google AI Overview

Google's AI-generated summary at the top of search results, extracted via SearchAPI.io. Critical for SEO visibility.

Each platform check extracts: whether your brand was mentioned, mention position (1st, 2nd, 3rd, etc.), mention type (recommended, listed, discussed, compared), competitor mentions and their positions, sentiment (positive, neutral, negative), brand attributes, source citation URLs, and the full AI response text for review.

The Query Performance Matrix is a heatmap showing how each of your tracking queries performs across all 5 AI platforms. Rows represent queries, columns represent platforms, and cells are color-coded by mention status and position.

• Green cells — your brand is mentioned (darker = higher position)
• Gray cells — your brand is not mentioned for that query on that platform
• Click any cell to drill down into the full AI response
• Sort by overall performance, individual platform, or query name
• Filter by topic, business value, or query intent type

TruIntel analyzes the sentiment and attributes that AI platforms associate with your brand. This reveals how AI "perceives" your brand — what qualities it highlights and whether the tone is positive or negative.

• Brand Attributes — themes and qualities AI associates with your brand (e.g., "innovative", "affordable", "reliable")
• Sentiment Distribution — breakdown of positive, neutral, and negative mentions across all platforms
• Mention Types — branded (your name), unbranded (your category), and competitor (mentions alongside competitors)
• Trend tracking — see how perception shifts over time with weekly snapshots

Share of Voice (SoV) measures your brand's proportion of total AI mentions compared to competitors for the same set of queries. A higher SoV means AI recommends you more frequently than competitors.

The SoV analysis includes a query × platform heatmap matrix, per-query SoV percentage, competitor breakdown showing who gets the most mentions, and trend analysis showing how your share changes over time.

When AI platforms cite sources in their responses, TruIntel tracks which domains are being referenced and whether your website is among them.

• Source Domains — which websites AI cites most frequently in your industry
• Source Types — editorial, earned media, owned content, UGC, corporate, marketplace
• Gap Analysis — identify high-authority sources that cite competitors but not you
• URL-level tracking — see exactly which pages on each source domain are cited
• Platform-specific sources — which platforms cite which sources

TruIntel runs visibility checks automatically based on your plan:

After every visibility check, TruIntel runs a post-check processing pipeline:

1. Response Analysis — AI analyzes each platform response for brand mentions, position, and sentiment
2. Domain Classification — cited source domains are categorized (corporate, editorial, UGC, earned, marketplace, etc.)
3. Alert Generation — automatic alerts for visibility drops (>= 5pt), competitor overtakes, and negative mentions
4. Insight Generation — weekly 4-step Gemini AI pipeline: Trend Analysis → Competitor Analysis → Strategy → Action Tasks
5. Dashboard Cache Refresh — real-time score updates across the platform

The SEO Dashboard provides a comprehensive overview of your website's search health. It aggregates data from PageSpeed checks, keyword rankings, backlink analysis, and on-page audits into a single health score.

• Site Health Stats Bar — pages crawled, issues found, avg response time, avg page score, broken links
• Search Performance Card — GSC data with interactive line chart (clicks, impressions, CTR, avg position)
• Top Pages by Inbound Links — pages with most internal links pointing to them
• Quick Wins Section — dynamic alerts for PageSpeed < 50, SSL expiration, broken links, image issues
• Images Preview — table of images missing alt text with inline fix button
• Competitor SEO Card — top 5 competitors with DA, trust score, backlinks, and referring domains
• DA & Trust vs Competitors Chart — horizontal bar chart comparing your domain against competitors

TruIntel includes 10 free SEO checks with all paid plans, run automatically monthly and available on-demand:

1. PageSpeed Insights — mobile + desktop performance scores via Lighthouse
2. Core Web Vitals — LCP, FID, CLS field data from Chrome UX Report
3. SSL Certificate — validity, expiry date, and issuer verification
4. Structured Data — JSON-LD schema detection and validation
5. Meta Tag Audit — title, description, Open Graph, and Twitter Cards
6. Robots.txt & Sitemap — accessibility, format, and coverage checks
7. Mobile-Friendly Assessment — responsive design and viewport validation
8. Readability Analysis — Flesch reading ease and Gunning Fog index scores
9. Content Quality — heading structure, link density, image optimization
10. Technology Detection — CMS, frameworks, CDN, and analytics tool identification

TruIntel measures your site's performance using Google Lighthouse methodology. Both mobile and desktop scores are tracked with detailed metric breakdowns.

Performance trends are tracked over time so you can measure the impact of optimizations. Each metric shows color-coded status: green (good), amber (needs improvement), or red (poor).

Track your keyword positions in Google search results. TruIntel combines data from Google Search Console (if connected) and third-party ranking APIs for comprehensive keyword tracking.

• Position Distribution — breakdown of keywords in Top 3, Top 10, Page 2, and below
• Position Changes — track which keywords improved or declined with delta indicators
• Search Volume & Difficulty — see estimated monthly searches and competition level
• Filter tabs: Improved, Declined, Top 10, All keywords
• Keyword History Chart — position trends for individual keywords over time
• AI-powered keyword suggestions based on your content and industry
• Position alerts — get notified when important keywords move significantly

Monitor your backlink profile to understand your site's authority. TruIntel tracks total backlinks, referring domains, and detects potentially toxic backlinks that could harm your SEO.

• Total Backlinks — count with trend over time
• Referring Domains — unique domains linking to your site
• Toxic Backlinks — identified harmful links that should be disavowed (Pro+ plans)
• Backlink Types — dofollow vs nofollow distribution
• Competitor Backlink Comparison — see who links to competitors but not you
• Backlink Opportunities — discover potential link-building targets

TruIntel's self-hosted BFS crawler scans your website and identifies technical SEO issues. Issues are categorized by severity: critical, warning, and informational.

The audit provides a Readability Score, Content Quality Score, and Search Visibility Score. Each issue includes a clear recommendation for how to fix it.

Compare your SEO metrics against competitors. See how your domain authority, keyword rankings, and backlink profile stack up.

• Domain Authority comparison chart
• Competitor top keywords with dropdown selector
• Keyword overlap analysis — shared vs unique keywords
• SEO metrics comparison (backlinks, referring domains, DA)
• Track multiple competitors simultaneously

TruIntel provides AI-powered keyword suggestions based on your content, industry, and existing keyword rankings. Suggestions include search volume, difficulty score, and relevance indicators.

• AI-generated keyword ideas based on your domain and industry
• Search volume and keyword difficulty metrics
• Relevance scoring to prioritize the best opportunities
• One-click add to your tracking keyword list
• Monthly suggestion limits based on plan tier (20–500/month)

Audit your website's images for SEO best practices including file size, format, alt text, and compression opportunities.

• Detect oversized images that slow down page load
• Check for missing or poor-quality alt text
• Recommend format conversions (e.g., PNG to WebP)
• Identify images without proper dimensions specified
• Compression recommendations with estimated savings

Keyword Gap Analysis compares your keyword rankings against competitors to find opportunities. Identify keywords that competitors rank for but you don't — these represent your biggest growth opportunities.

Backlink Gap Analysis identifies domains that link to your competitors but not to you. Target these domains for outreach to close the gap and improve your domain authority.

The On-Page SEO Checker performs a page-by-page audit of your website, identifying specific issues with actionable fix recommendations categorized by severity (critical, warning, info).

The Crawl Visualization tool displays your website's link structure as an interactive directed acyclic graph (DAG). It uses React Flow to render pages as nodes and internal links as edges, helping you identify orphan pages, deep pages, and crawl issues.

• Interactive graph with zoom, pan, and node selection
• Detail panel showing page metadata, links, and issues
• Orphan page detection — pages with no internal links pointing to them
• Crawl depth visualization — see how deep pages are from the homepage
• Toolbar with layout options and filtering controls

Connect your Google Search Console account for enhanced keyword tracking with real search data.

• Tracks: clicks, impressions, CTR, and average position per keyword
• Keywords enriched with search volume data via DataForSEO
• Position changes calculated with 7-day comparison window
• Available to all paid plans — data refreshed daily
• View GSC data in the Search Performance page with advanced filters

TruIntel generates weekly AI-powered insight reports using a 4-step Gemini Flash pipeline. Each report analyzes your visibility data, competitor movements, and industry trends to produce actionable findings and tasks.

Each insight report contains 5–10 findings. Every finding includes:

• Finding Title — a clear, concise description of what was observed
• Impact Score — how significant this finding is for your brand (1–10)
• Evidence — data points and specific examples supporting the finding
• Category — trend, competitor, opportunity, risk, or achievement
• Related Tasks — actionable items generated from this finding

Findings are ranked by impact score so you can focus on what matters most. Each finding maps to one or more tasks, creating a clear path from insight to action.

Tasks generated by the insights pipeline follow a simple lifecycle. Each task has a status, category, priority, and impact score.

Tasks can be viewed in two modes: Split View (list on left, detail on right) or Kanban Board (columns for todo, done, dismissed). Filter tasks by status, category (earned/owned), or group.

TruIntel generates comprehensive weekly and monthly brand reports that consolidate your AEO performance, SEO health, traffic intelligence, and lead verification data into executive-ready summaries.

Each report contains 8 sections:

1. Executive Summary — high-level overview with key metrics and trends
2. AEO Performance — visibility score changes, platform breakdown, and recognition rate
3. Platform Analysis — per-platform performance with ChatGPT, Claude, Gemini, Perplexity, and Google AI Overview
4. Competitor Benchmarking — how you compare against tracked competitors
5. SEO Health — domain authority, keyword rankings, backlink profile, and technical audit status
6. Traffic Intelligence — visitor classification, bot detection, and traffic trends
7. Leads — lead verification summary, conversion funnel, and quality distribution
8. Findings — key insights and recommendations from the AI analysis pipeline

Reports can be exported as multi-page A4 PDFs using html2canvas and jsPDF. The PDF preserves all charts, tables, and visualizations from the report detail page.

TruIntel sends weekly email reports every Monday (after brand reports are generated) to all organization members. The email includes a visibility summary, score changes, and key alerts for the past week.

TruIntel's Traffic Classification system analyzes every visitor to your website and classifies them into one of four categories. This helps you understand your real traffic, identify AI agent visits, and filter malicious bots.

Every visitor receives a Classification Score (0–100) based on four weighted signals:

• Behavior Analysis (45%) — mouse movements, scroll patterns, click timing, page dwell time
• Browser Fingerprint (30%) — canvas fingerprint, WebGL, installed fonts, timezone, screen resolution
• User Agent (15%) — user-agent string parsing, known bot patterns, header consistency
• Network Analysis (10%) — IP reputation, hosting provider detection, datacenter vs residential IP

TruIntel uses a two-part tracking system for complete traffic intelligence. The client-side script runs in the browser to detect real humans, headless browsers, and browser-based bots. The server-side middleware intercepts AI crawlers (GPTBot, ClaudeBot, PerplexityBot, etc.) that never execute JavaScript. Deploy both for the most accurate classification.

Client-Side Script

The client-side script classifies visitors using behavior analysis (mouse movements, scroll patterns, click timing), browser fingerprinting (canvas, WebGL, fonts, timezone), and user-agent parsing. It loads asynchronously, never blocks rendering, and sends data in fire-and-forget mode. No cookies are set and no personally identifiable information (PII) is collected.

HTML

Add this snippet inside the <head> tag on every page you want to track. Both script tags are required — the first sets the config, the second loads the tracker.

<!-- TruIntel Traffic Tracking -->
<script>
  window.TruIntel = {
    brandId: 'YOUR_BRAND_ID',
    apiUrl: 'https://api.truintel.ai/api/v1'
  };
</script>
<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>

React

Create a tracker component and render it once at the root of your app (App.tsx or main layout). The cleanup function removes the script on unmount to prevent duplicates in development mode.

import { useEffect } from 'react';

export function TruIntelTracker() {
  useEffect(() => {
    window.TruIntel = {
      brandId: 'YOUR_BRAND_ID',
      apiUrl: 'https://api.truintel.ai/api/v1'
    };
    const s = document.createElement('script');
    s.async = true;
    s.src = 'https://api.truintel.ai/api/v1/traffic/tracker.js';
    document.head.appendChild(s);
    return () => { document.head.removeChild(s); };
  }, []);
  return null;
}

// Usage in App.tsx:
// import { TruIntelTracker } from './TruIntelTracker';
// function App() { return <><TruIntelTracker /><Router>...</Router></>; }

Next.js

Use the Next.js Script component for optimized loading. The config must use beforeInteractive to ensure it loads before the tracker. Works with both App Router (app/layout.tsx) and Pages Router (_app.tsx).

import Script from 'next/script';

export default function RootLayout({ children }) {
  return (
    <html>
      <head>
        {/* Config MUST load before tracker.js */}
        <Script id="truintel-config" strategy="beforeInteractive"
          dangerouslySetInnerHTML={{
            __html: `window.TruIntel={brandId:'YOUR_BRAND_ID',apiUrl:'https://api.truintel.ai/api/v1'};`,
          }} />
        <Script src="https://api.truintel.ai/api/v1/traffic/tracker.js"
          strategy="afterInteractive" />
      </head>
      <body>{children}</body>
    </html>
  );
}

Vue

Use lifecycle hooks to inject the script in your root App.vue or main layout component. The script is cleaned up on component unmount.

<script setup>
import { onMounted, onUnmounted } from 'vue';

let script = null;

onMounted(() => {
  window.TruIntel = {
    brandId: 'YOUR_BRAND_ID',
    apiUrl: 'https://api.truintel.ai/api/v1'
  };
  script = document.createElement('script');
  script.async = true;
  script.src = 'https://api.truintel.ai/api/v1/traffic/tracker.js';
  document.head.appendChild(script);
});

onUnmounted(() => {
  if (script) document.head.removeChild(script);
});
</script>

Nuxt

Add to your nuxt.config.ts to inject the script globally on every page. Nuxt handles the script loading order automatically.

export default defineNuxtConfig({
  app: {
    head: {
      script: [
        {
          innerHTML: "window.TruIntel={brandId:'YOUR_BRAND_ID',apiUrl:'https://api.truintel.ai/api/v1'};",
        },
        {
          src: 'https://api.truintel.ai/api/v1/traffic/tracker.js',
          async: true,
        },
      ],
    },
  },
});

Svelte / SvelteKit

For SvelteKit, add to src/app.html inside the <head> tag. Alternatively, use <svelte:head> in your root +layout.svelte for dynamic injection.

<svelte:head>
  {@html `<script>window.TruIntel={brandId:'YOUR_BRAND_ID',apiUrl:'https://api.truintel.ai/api/v1'};</script>`}
  {@html `<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>`}
</svelte:head>

Angular

Add the script tags directly to your src/index.html inside the <head> tag. This is the simplest approach and works for all Angular versions.

<!-- Inside <head> -->
<script>
  window.TruIntel = {
    brandId: 'YOUR_BRAND_ID',
    apiUrl: 'https://api.truintel.ai/api/v1'
  };
</script>
<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>

WordPress

Add to your theme's functions.php file. If you use a child theme, add it there instead so updates don't overwrite it. Alternatively, use a plugin like "Insert Headers and Footers" or "WPCode" to inject without editing theme files.

// Add to your theme's functions.php
function truintel_tracking_script() {
  echo '<!-- TruIntel Traffic Tracking -->
<script>
  window.TruIntel = {
    brandId: "YOUR_BRAND_ID",
    apiUrl: "https://api.truintel.ai/api/v1"
  };
</script>
<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>';
}
add_action('wp_head', 'truintel_tracking_script');

Server-Side Middleware

AI crawlers like GPTBot, ClaudeBot, and PerplexityBot typically don't execute JavaScript — they fetch raw HTML and parse it directly. The client-side script alone cannot detect them. Server-side middleware inspects the User-Agent header on every incoming request and forwards matching bot traffic to TruIntel's classification API. The API call is fire-and-forget: it runs asynchronously and never blocks or slows down the response to the visitor.

Next.js Middleware

Create middleware.ts at the root of your Next.js project (next to package.json, not inside src/). The matcher config excludes static assets, images, and API routes from bot detection.

import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

const BRAND_ID = 'YOUR_BRAND_ID';
const TRUINTEL_API = 'https://api.truintel.ai/api/v1/i/e';

// AI crawlers — expand from Pattern Catalog for 90+ patterns
const AI_CRAWLERS = [
  'GPTBot','ChatGPT-User','OAI-SearchBot','ChatGPT-Agent',
  'ClaudeBot','Claude-Web','Claude-SearchBot','anthropic-ai',
  'Google-Extended','GoogleOther','Gemini-Deep-Research',
  'bingbot','BingPreview','Copilot','AzureAI-SearchBot',
  'PerplexityBot','Perplexity-User',
  'Meta-ExternalAgent','Meta-ExternalFetcher',
  'Applebot','Applebot-Extended',
  'GrokBot','xAI-Grok','Bytespider',
  'DeepseekBot','MistralAI-User','Amazonbot',
  'CCBot','Diffbot','YouBot','FirecrawlAgent',
];
const OTHER_BOTS = [
  'Googlebot','DuckDuckBot','YandexBot','Baiduspider',
  'Slackbot','Twitterbot','LinkedInBot',
  'facebookexternalhit','WhatsApp','Discordbot',
];
const ALL = [...AI_CRAWLERS, ...OTHER_BOTS];

function isBot(ua: string): boolean {
  if (!ua) return true;
  const lower = ua.toLowerCase();
  if (ALL.some(p => lower.includes(p.toLowerCase()))) return true;
  if (lower.includes('bot/') || lower.includes('spider/')
      || lower.includes('crawler/')) return true;
  if (lower.includes('mozilla/5.0') && lower.includes('applewebkit')) return false;
  return true;
}

export function middleware(req: NextRequest) {
  const ua = req.headers.get('user-agent') || '';

  if (isBot(ua)) {
    const ip = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || '';

    // Fire-and-forget — never blocks or slows the response
    fetch(TRUINTEL_API, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'X-Forwarded-For': ip },
      body: JSON.stringify({
        brand_id: BRAND_ID,
        page: req.nextUrl.pathname + req.nextUrl.search,
        user_agent: ua,
        referrer: req.headers.get('referer') || null,
        is_new_session: true,
        is_new_visitor: true,
      }),
    }).catch(() => {});
  }

  return NextResponse.next();
}

// Exclude static assets, images, and API routes
export const config = {
  matcher: [
    '/((?!_next/static|_next/image|favicon.ico|api/|.*\\.(svg|png|jpg|jpeg|gif|webp|ico|css|js|woff|woff2)$).*)',
  ],
};

Express.js

Create a middleware file and register it with app.use(). Place it early in your middleware chain (before route handlers) so every request is checked.

const BRAND_ID = 'YOUR_BRAND_ID';
const TRUINTEL_API = 'https://api.truintel.ai/api/v1/i/e';

const AI_CRAWLERS = [
  'GPTBot','ChatGPT-User','OAI-SearchBot','ChatGPT-Agent',
  'ClaudeBot','Claude-Web','Claude-SearchBot','anthropic-ai',
  'Google-Extended','GoogleOther','Gemini-Deep-Research',
  'bingbot','BingPreview','Copilot',
  'PerplexityBot','Meta-ExternalAgent','Applebot',
  'GrokBot','Bytespider','DeepseekBot','Amazonbot',
  'CCBot','Diffbot','YouBot','FirecrawlAgent',
];
const OTHER_BOTS = [
  'Googlebot','DuckDuckBot','YandexBot','Slackbot',
  'Twitterbot','LinkedInBot','facebookexternalhit','Discordbot',
];
const ALL = [...AI_CRAWLERS, ...OTHER_BOTS];

function isBot(ua) {
  if (!ua) return true;
  const lower = ua.toLowerCase();
  if (ALL.some(p => lower.includes(p.toLowerCase()))) return true;
  if (lower.includes('bot/') || lower.includes('spider/')
      || lower.includes('crawler/')) return true;
  if (lower.includes('mozilla/5.0') && lower.includes('applewebkit')) return false;
  return true;
}

function truintelMiddleware(req, res, next) {
  const ua = req.headers['user-agent'] || '';
  if (isBot(ua)) {
    const ip = (req.headers['x-forwarded-for'] || '').split(',')[0].trim()
        || req.socket?.remoteAddress || '';
    fetch(TRUINTEL_API, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'X-Forwarded-For': ip },
      body: JSON.stringify({
        brand_id: BRAND_ID,
        page: req.originalUrl || req.url,
        user_agent: ua,
        referrer: req.headers['referer'] || null,
        is_new_session: true,
        is_new_visitor: true,
      }),
    }).catch(() => {});
  }
  next();
}

module.exports = truintelMiddleware;

// Usage: const truintel = require('./truintel-middleware');
//        app.use(truintel);

Django

Create a middleware class and add it to your MIDDLEWARE list in settings.py. The API call runs in a background thread so it never blocks request processing.

import threading, json, urllib.request

BRAND_ID = 'YOUR_BRAND_ID'
TRUINTEL_API = 'https://api.truintel.ai/api/v1/i/e'

AI_CRAWLERS = [
    'GPTBot','ChatGPT-User','OAI-SearchBot','ChatGPT-Agent',
    'ClaudeBot','Claude-Web','Claude-SearchBot','anthropic-ai',
    'Google-Extended','GoogleOther','Gemini-Deep-Research',
    'bingbot','BingPreview','Copilot',
    'PerplexityBot','Meta-ExternalAgent','Applebot',
    'GrokBot','Bytespider','DeepseekBot','Amazonbot',
    'CCBot','Diffbot','YouBot','FirecrawlAgent',
]
OTHER_BOTS = [
    'Googlebot','DuckDuckBot','YandexBot','Slackbot',
    'Twitterbot','LinkedInBot','facebookexternalhit','Discordbot',
]
ALL_PATTERNS = AI_CRAWLERS + OTHER_BOTS

def is_bot(ua):
    if not ua:
        return True
    lower = ua.lower()
    if any(p.lower() in lower for p in ALL_PATTERNS):
        return True
    if any(x in lower for x in ['bot/', 'spider/', 'crawler/']):
        return True
    if 'mozilla/5.0' in lower and 'applewebkit' in lower:
        return False
    return True

def _send(data, ip):
    try:
        req = urllib.request.Request(
            TRUINTEL_API, json.dumps(data).encode(),
            headers={'Content-Type': 'application/json', 'X-Forwarded-For': ip},
            method='POST'
        )
        urllib.request.urlopen(req, timeout=5)
    except Exception:
        pass

class TruIntelCrawlerMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        ua = request.META.get('HTTP_USER_AGENT', '')
        if is_bot(ua):
            forwarded = request.META.get('HTTP_X_FORWARDED_FOR', '')
            ip = forwarded.split(',')[0].strip() if forwarded else request.META.get('REMOTE_ADDR', '')
            data = {
                'brand_id': BRAND_ID,
                'page': request.get_full_path(),
                'user_agent': ua,
                'referrer': request.META.get('HTTP_REFERER'),
                'is_new_session': True,
                'is_new_visitor': True,
            }
            threading.Thread(target=_send, args=(data, ip), daemon=True).start()
        return self.get_response(request)

# settings.py:
# MIDDLEWARE = ['yourapp.truintel_middleware.TruIntelCrawlerMiddleware', ...]

FastAPI

Add middleware using Starlette's BaseHTTPMiddleware. The API call runs in a background thread to keep the async event loop unblocked.

import threading, json, urllib.request
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request

BRAND_ID = 'YOUR_BRAND_ID'
TRUINTEL_API = 'https://api.truintel.ai/api/v1/i/e'

AI_CRAWLERS = [
    'GPTBot','ChatGPT-User','OAI-SearchBot','ChatGPT-Agent',
    'ClaudeBot','Claude-Web','Claude-SearchBot','anthropic-ai',
    'Google-Extended','GoogleOther','Gemini-Deep-Research',
    'PerplexityBot','Meta-ExternalAgent','Applebot',
    'GrokBot','Bytespider','DeepseekBot','Amazonbot','CCBot',
]
OTHER_BOTS = [
    'Googlebot','DuckDuckBot','YandexBot','Slackbot',
    'Twitterbot','LinkedInBot','facebookexternalhit','Discordbot',
]
ALL_PATTERNS = AI_CRAWLERS + OTHER_BOTS

def _is_bot(ua):
    if not ua:
        return True
    lower = ua.lower()
    if any(p.lower() in lower for p in ALL_PATTERNS):
        return True
    if any(x in lower for x in ['bot/', 'spider/', 'crawler/']):
        return True
    if 'mozilla/5.0' in lower and 'applewebkit' in lower:
        return False
    return True

def _send(data, ip):
    try:
        req = urllib.request.Request(
            TRUINTEL_API, json.dumps(data).encode(),
            headers={'Content-Type': 'application/json', 'X-Forwarded-For': ip},
            method='POST'
        )
        urllib.request.urlopen(req, timeout=5)
    except Exception:
        pass

class TruIntelMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        ua = request.headers.get('user-agent', '')
        if _is_bot(ua):
            forwarded = request.headers.get('x-forwarded-for', '')
            ip = forwarded.split(',')[0].strip() if forwarded else (str(request.client.host) if request.client else '')
            data = {
                'brand_id': BRAND_ID,
                'page': str(request.url.path) + ('?' + str(request.url.query) if request.url.query else ''),
                'user_agent': ua,
                'referrer': request.headers.get('referer'),
                'is_new_session': True,
                'is_new_visitor': True,
            }
            threading.Thread(target=_send, args=(data, ip), daemon=True).start()
        return await call_next(request)

# main.py:
# from truintel_middleware import TruIntelMiddleware
# app.add_middleware(TruIntelMiddleware)

Flask

Use Flask's before_request hook to check every incoming request. Import and call init_truintel(app) in your main app file.

import threading, json, urllib.request
from flask import request

BRAND_ID = 'YOUR_BRAND_ID'
TRUINTEL_API = 'https://api.truintel.ai/api/v1/i/e'

AI_CRAWLERS = [
    'GPTBot','ChatGPT-User','OAI-SearchBot','ChatGPT-Agent',
    'ClaudeBot','Claude-Web','Claude-SearchBot','anthropic-ai',
    'Google-Extended','GoogleOther','Gemini-Deep-Research',
    'PerplexityBot','Meta-ExternalAgent','Applebot',
    'GrokBot','Bytespider','DeepseekBot','Amazonbot','CCBot',
]
OTHER_BOTS = [
    'Googlebot','DuckDuckBot','YandexBot','Slackbot',
    'Twitterbot','LinkedInBot','facebookexternalhit','Discordbot',
]
ALL_PATTERNS = AI_CRAWLERS + OTHER_BOTS

def _is_bot(ua):
    if not ua:
        return True
    lower = ua.lower()
    if any(p.lower() in lower for p in ALL_PATTERNS):
        return True
    if any(x in lower for x in ['bot/', 'spider/', 'crawler/']):
        return True
    if 'mozilla/5.0' in lower and 'applewebkit' in lower:
        return False
    return True

def _send(data, ip):
    try:
        req = urllib.request.Request(
            TRUINTEL_API, json.dumps(data).encode(),
            headers={'Content-Type': 'application/json', 'X-Forwarded-For': ip},
            method='POST'
        )
        urllib.request.urlopen(req, timeout=5)
    except Exception:
        pass

def init_truintel(app):
    @app.before_request
    def track_bots():
        ua = request.headers.get('User-Agent', '')
        if _is_bot(ua):
            forwarded = request.headers.get('X-Forwarded-For', '')
            ip = forwarded.split(',')[0].strip() if forwarded else (request.remote_addr or '')
            data = {
                'brand_id': BRAND_ID,
                'page': request.full_path,
                'user_agent': ua,
                'referrer': request.referrer,
                'is_new_session': True,
                'is_new_visitor': True,
            }
            threading.Thread(target=_send, args=(data, ip), daemon=True).start()

# app.py:
# from truintel_middleware import init_truintel
# init_truintel(app)

Go (net/http)

Create an HTTP middleware handler. The API call runs in a goroutine so it never blocks the response. Wrap your router with TruIntelMiddleware(router).

package main

import (
	"bytes"
	"encoding/json"
	"net/http"
	"strings"
)

const brandID = "YOUR_BRAND_ID"
const truintelAPI = "https://api.truintel.ai/api/v1/i/e"

var aiCrawlers = []string{
	"GPTBot","ChatGPT-User","OAI-SearchBot","ChatGPT-Agent",
	"ClaudeBot","Claude-Web","Claude-SearchBot","anthropic-ai",
	"Google-Extended","GoogleOther","Gemini-Deep-Research",
	"PerplexityBot","Meta-ExternalAgent","Applebot",
	"GrokBot","Bytespider","DeepseekBot","Amazonbot","CCBot",
}
var otherBots = []string{
	"Googlebot","DuckDuckBot","YandexBot","Slackbot",
	"Twitterbot","LinkedInBot","facebookexternalhit","Discordbot",
}

func isBot(ua string) bool {
	if ua == "" { return true }
	lower := strings.ToLower(ua)
	for _, p := range append(aiCrawlers, otherBots...) {
		if strings.Contains(lower, strings.ToLower(p)) { return true }
	}
	for _, x := range []string{"bot/", "spider/", "crawler/"} {
		if strings.Contains(lower, x) { return true }
	}
	if strings.Contains(lower, "mozilla/5.0") && strings.Contains(lower, "applewebkit") {
		return false
	}
	return true
}

func TruIntelMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ua := r.UserAgent()
		if isBot(ua) {
			ip := strings.Split(r.Header.Get("X-Forwarded-For"), ",")[0]
			if ip == "" { ip = strings.Split(r.RemoteAddr, ":")[0] }
			go func() {
				body, _ := json.Marshal(map[string]interface{}{
					"brand_id": brandID,
					"page": r.URL.RequestURI(),
					"user_agent": ua,
					"referrer": r.Referer(),
					"is_new_session": true, "is_new_visitor": true,
				})
				req, _ := http.NewRequest("POST", truintelAPI, bytes.NewReader(body))
				req.Header.Set("Content-Type", "application/json")
				req.Header.Set("X-Forwarded-For", ip)
				http.DefaultClient.Do(req)
			}()
		}
		next.ServeHTTP(w, r)
	})
}

// Usage: http.ListenAndServe(":8080", TruIntelMiddleware(router))

Verification & Testing

After installing both scripts, verify that traffic data is flowing correctly into your TruIntel dashboard.

# Simulate GPTBot visiting your homepage
curl -s https://yoursite.com/ \
  -H "User-Agent: Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko) GPTBot/1.0"

# Simulate ClaudeBot
curl -s https://yoursite.com/ \
  -H "User-Agent: ClaudeBot/1.0 (https://anthropic.com)"

# If your middleware is working, both visits appear in TruIntel
# within seconds, classified as GOOD_AGENT

Content Security Policy (CSP)

If your site uses Content Security Policy headers, you need to allow the TruIntel tracker script and its API endpoint. Add these directives to your CSP header:

Content-Security-Policy:
  script-src 'self' https://api.truintel.ai;
  connect-src 'self' https://api.truintel.ai;

Troubleshooting

Edge Cases

Privacy & Performance

• Script size: ~5 KB gzipped (loads async, non-blocking)
• Beacon size: ~200 bytes per event (fire-and-forget POST)
• Rate limit: 100 requests/minute per IP (client-side), no limit on server-side middleware
• Zero cookies set — no cookie-consent banner interaction required
• No impact on Core Web Vitals (LCP, FID, CLS) — verified via Lighthouse
• Server-side middleware adds 0ms latency — API call runs asynchronously in background

The Traffic Dashboard provides real-time visibility into your website visitors.

Use the Rules Manager to create whitelist/blacklist rules for specific IPs, user agents, or patterns. Browse the built-in Pattern Catalog for known bot signatures.

TruIntel's lead verification works by automatically intercepting form submissions on your website. A single script detects all <form> elements, captures submission data along with behavioral signals, and scores each lead in real time. No backend changes are required — the same tracker script used for traffic classification also handles lead verification.

How It Works

What Data Is Captured

Installation Steps

Script Installation

This is the same script used for Traffic Classification. If you've already installed it, lead verification is already active.

HTML

Paste inside the <head> tag on every page that has forms you want to track.

<!-- TruIntel Lead Verification -->
<script>
  window.TruIntel = {
    brandId: 'YOUR_BRAND_ID',
    apiUrl: 'https://api.truintel.ai/api/v1'
  };
</script>
<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>

React

Add once in your App.tsx or root layout component. The tracker persists across route changes and detects dynamically rendered forms.

import { useEffect } from 'react';

export function TruIntelTracker() {
  useEffect(() => {
    window.TruIntel = {
      brandId: 'YOUR_BRAND_ID',
      apiUrl: 'https://api.truintel.ai/api/v1'
    };
    const s = document.createElement('script');
    s.async = true;
    s.src = 'https://api.truintel.ai/api/v1/traffic/tracker.js';
    document.head.appendChild(s);
    return () => { document.head.removeChild(s); };
  }, []);
  return null;
}

// Usage: <TruIntelTracker />

Next.js

Add to your root layout (app/layout.tsx for App Router, _app.tsx for Pages Router).

import Script from 'next/script';

export default function RootLayout({ children }) {
  return (
    <html>
      <head>
        <Script id="truintel-config" strategy="beforeInteractive"
          dangerouslySetInnerHTML={{
            __html: `window.TruIntel={brandId:'YOUR_BRAND_ID',apiUrl:'https://api.truintel.ai/api/v1'};`,
          }} />
        <Script src="https://api.truintel.ai/api/v1/traffic/tracker.js"
          strategy="afterInteractive" />
      </head>
      <body>{children}</body>
    </html>
  );
}

Vue

Add to your root App.vue or main entry component.

<script setup>
import { onMounted, onUnmounted } from 'vue';

let script = null;

onMounted(() => {
  window.TruIntel = {
    brandId: 'YOUR_BRAND_ID',
    apiUrl: 'https://api.truintel.ai/api/v1'
  };
  script = document.createElement('script');
  script.async = true;
  script.src = 'https://api.truintel.ai/api/v1/traffic/tracker.js';
  document.head.appendChild(script);
});

onUnmounted(() => {
  if (script) document.head.removeChild(script);
});
</script>

Nuxt

Add to your nuxt.config.ts to inject the script globally on every page.

export default defineNuxtConfig({
  app: {
    head: {
      script: [
        {
          innerHTML: "window.TruIntel={brandId:'YOUR_BRAND_ID',apiUrl:'https://api.truintel.ai/api/v1'};",
        },
        {
          src: 'https://api.truintel.ai/api/v1/traffic/tracker.js',
          async: true,
        },
      ],
    },
  },
});

Angular

Add to src/index.html inside the <head> tag.

<!-- Inside <head> -->
<script>
  window.TruIntel = {
    brandId: 'YOUR_BRAND_ID',
    apiUrl: 'https://api.truintel.ai/api/v1'
  };
</script>
<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>

Svelte / SvelteKit

Add to src/app.html inside the <head> tag, or use <svelte:head> in your root layout.

<svelte:head>
  {@html `<script>window.TruIntel={brandId:'YOUR_BRAND_ID',apiUrl:'https://api.truintel.ai/api/v1'};</script>`}
  {@html `<script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>`}
</svelte:head>

WordPress

Add to your theme's functions.php, or use a plugin like "Insert Headers and Footers" or "WPCode" to inject without editing theme files.

// Add to your theme's functions.php
add_action('wp_head', function() {
  ?>
  <script>
    window.TruIntel = {
      brandId: 'YOUR_BRAND_ID',
      apiUrl: 'https://api.truintel.ai/api/v1'
    };
  </script>
  <script async src="https://api.truintel.ai/api/v1/traffic/tracker.js"></script>
  <?php
});

Excluding Forms

By default, TruIntel tracks all form submissions on the page. To exclude specific forms from being tracked, add the data-ti-ignore attribute to the <form> element.

<!-- This form will NOT be tracked -->
<form action="/login" method="POST" data-ti-ignore>
  <input type="email" name="email" />
  <input type="password" name="password" />
  <button type="submit">Log in</button>
</form>

<!-- This form WILL be tracked -->
<form action="/contact" method="POST">
  <input type="text" name="name" placeholder="Full name" />
  <input type="email" name="email" placeholder="Work email" />
  <textarea name="message"></textarea>
  <button type="submit">Send</button>
</form>

Edge Cases & Advanced Scenarios

Troubleshooting

Privacy & Sensitive Data

• Password fields (type="password") are NEVER captured — automatically excluded
• Fields named "password", "passwd", "secret", "token", "credit_card", "cvv", "ssn" are auto-excluded
• Credit card numbers are detected and redacted before transmission (pattern matching)
• File contents are never uploaded — only filename and size are recorded
• All data is transmitted over HTTPS (TLS 1.3) and encrypted at rest
• Lead data is retained for 90 days by default — configurable in Settings → Data Retention
• No cookies are set — the tracker uses sessionStorage for session-scoped data only
• GDPR: Lead data containing PII (email, name, phone) is processed under "legitimate interest" — consult your legal team for your specific jurisdiction

Every form submission on your website receives a Lead Score (0–100) that indicates how likely it is to be a genuine, high-quality lead.

Leads are automatically categorized into three status levels based on their score:

The Leads Dashboard shows conversion funnel, score distribution charts, and trend analysis. You can manually override lead status, bulk-update statuses, and export lead data for CRM integration.

Integrate lead verification into your forms using TruIntel's public API endpoint:

POST https://api.truintel.ai/api/v1/leads/verify

# Rate limit: 20 requests/minute per IP
# No authentication required (uses brand ID)

# Request body:
{
  "brand_id": "your-brand-id",
  "email": "[email protected]",
  "name": "John Doe",
  "company": "Acme Inc",
  "phone": "+1234567890",
  "page_url": "https://yoursite.com/contact",
  "referrer": "https://google.com",
  "user_agent": "Mozilla/5.0 ..."
}

The API returns a score, status (verified/review/rejected), and detailed signal breakdown. Use this to pre-filter form submissions before they reach your CRM.

TruIntel CMS generates high-quality, SEO-optimized content using a 5-step AI pipeline powered by Gemini Flash.

Content generation uses credits from your credit pool. You can poll generation progress in real-time — each step shows its status as it completes.

TruIntel CMS includes a full-featured rich text editor built on TipTap for creating and editing content.

The editor also includes AI Assist — select text and choose to rewrite, expand, or shorten it using AI. Schema markup (FAQPage, Article, WebPage) is auto-generated based on content structure.

TruIntel publishes content to Cloudflare's global edge network using a 3-tier fallback system for maximum compatibility with your existing website.

Published content is stored in Cloudflare KV and served globally via Workers. Sitemaps are auto-generated and search engines are pinged on publish. You can unpublish content at any time.

Connect your custom domain to publish TruIntel-generated content on your own website.

The CMS Optimization feature scans your existing website pages and identifies issues that can be fixed to improve SEO and AI visibility.

• AI-powered page scanning identifies issues across meta tags, headings, content, and structured data
• Preview fixes before applying — see exactly what will change
• Batch fix multiple issues at once with progress tracking
• Undo support — revert any fix to its original state
• Credit usage tracking for optimization operations

The CMS site scanner crawls up to 200 pages per scan using a 5-phase pipeline:

TruIntel automatically refreshes published content monthly (1st of each month at 3:00 AM IST). The refresh detects stale or outdated sections and regenerates them to keep your content current and competitive.

TruIntel provides AI-powered content generation templates organized into three categories.

Each template follows a step-based wizard: select template → configure options (target queries, custom context, tone) → generate → preview and download. Output is available in Markdown format with copy and download actions.

Content generation and CMS operations consume credits. Each article or content piece generated costs 1 credit. Credits are drawn from two pools in order:

You can also purchase top-up credit packs at discounted rates:

Credit balance and usage history are visible in Settings → Billing. Top-up purchases are processed via Razorpay and never expire.

Tracking queries are the questions and search terms that TruIntel monitors across AI platforms. These are the queries your potential customers might ask AI assistants about your industry.

• Add queries individually or in bulk (CSV upload)
• Each query can be assigned a business value (1–5) for prioritization
• Queries are classified by intent: informational, commercial, transactional, navigational, or comparison
• Set status: active (being tracked), suggested (AI recommendation), or inactive (paused)
• Assign to topics for organized grouping
• Set country/locale for region-specific monitoring
• Toggle priority flag for priority checks (available on higher plans)

Group related queries into Topics for better organization and analysis. Topics appear as filter options throughout the visibility dashboard.

• Create, edit, and delete topics from the Topics Management modal
• Bulk-create topics from AI suggestions based on your industry
• Each query belongs to one topic
• Filter visibility data by topic to focus on specific areas
• Topics help the AI insights engine group related findings

TruIntel uses AI to suggest relevant tracking queries based on your brand, industry, competitors, and existing queries. Suggestions are refreshed periodically and can be accepted individually or in bulk.

When AI platforms respond to queries, they often cite source domains. TruIntel tracks which domains are referenced and categorizes them by type.

A donut chart on the Sources page shows the distribution of source types. Click any source to see URL-level detail and which platforms cite it.

Gap Analysis identifies high-authority sources that cite your competitors but not you. These represent your biggest opportunities for improving AI visibility.

Prompt Research is an AI-powered research tool that lets you explore how AI platforms discuss your industry in real time. Enter a seed topic and TruIntel generates 20–30 relevant search prompts organized into 5–8 topic clusters, then queries all 5 AI platforms and analyzes responses for brand mentions, sources, and sentiment.

• Enter a seed topic → AI generates 20–30 search prompts in 5–8 topic clusters
• Queries all 5 AI platforms simultaneously and analyzes responses
• Discover what AI says about your industry, competitors, or specific topics
• Identify brand mentions, source citations, and sentiment across platforms
• Find new query opportunities for your visibility tracking
• No per-plan limit on research sessions — available to all paid plans

TruIntel automatically discovers and tracks competitors in your industry. You can also manually add competitors by entering their domain.

• Auto-discovery during onboarding based on industry and AI mentions
• Manual add/remove with domain validation
• Per-competitor visibility scores and sentiment
• Ranking chart comparing your brand against competitors
• Sentiment distribution (positive/neutral/negative) per competitor
• Score change indicators showing who's improving or declining

The Competitors page and Overview dashboard show how you stack up against competitors across multiple dimensions.

TruIntel monitors your brand continuously and sends alerts when significant events occur.

Alerts appear in the notification bell in the top bar, on the dedicated Notifications page, and optionally via email. HIGH and CRITICAL alerts trigger email notifications automatically. Each alert can be marked as read or resolved. Filter alerts by All, Unread, Read, or Critical tabs.

Customize which alerts you receive and how from Settings → Notifications.

• Toggle individual alert types: Weekly Reports, Visibility Drops, Competitor Detected, Check Completed, Traffic Anomaly
• Choose email frequency: Instant (send immediately), Daily Digest (once per day), Weekly Digest (once per week)
• HIGH/CRITICAL severity alerts always trigger email notifications
• View and manage all alerts on the Notifications page with pagination (20 per page)
• Bulk mark all as read with one click

Manage your personal account details from Settings → Profile.

• Update your name, avatar, and email address
• Change your password (current password required)
• Logout from all devices (revokes all refresh tokens)
• View and switch between organizations you belong to

Manage your team from Settings → Team. Invite new members, change roles, and remove members.

• View all current team members with their roles and join dates
• Invite new members by email — they receive an invitation link valid for 7 days
• Change member roles (Owner, Admin, Member)
• View pending invitations and resend or cancel them
• Remove team members (Owner/Admin only)

View your current plan, manage subscriptions, and purchase credits from Settings → Billing.

• Current plan name, renewal date, and status
• Usage metrics — brands used, queries tracked, checks performed
• Payment history with downloadable receipts
• Upgrade or downgrade plan via Razorpay checkout
• Credit balance across Plan Credits and Extra Credits pools
• One-click credit top-up with custom amounts

Generate API keys for programmatic access to your TruIntel data from Settings → API Keys.

• Generate new API keys with optional description/label
• Copy keys to clipboard (keys are only shown once at creation)
• Delete keys to revoke access immediately
• API keys inherit the permissions of the creating user

Submit support tickets and track their status from Settings → Support.

• Create support tickets with category, subject, and description
• View ticket history with status tracking (open, in progress, resolved)
• Receive email updates when ticket status changes

TruIntel offers a 7-day free trial and four paid subscription tiers to fit businesses of all sizes. The free trial includes 1 brand, 5 queries, and 1 competitor to help you evaluate the platform.

TruIntel processes payments securely, supporting credit cards, debit cards, UPI, and net banking.

• Subscriptions are billed monthly with automatic renewal via Razorpay
• Upgrade or downgrade your plan at any time — changes take effect immediately
• Credit top-ups are one-time purchases that never expire
• View complete payment history in Settings → Billing
• Receipts are downloadable for each payment
• Failed payments trigger automatic retry and email notification
• India billing: 18% GST (IGST) is automatically added for Indian customers, detected via IP geolocation

The SERP Simulator lets you preview how your web pages appear in search engine results before publishing. It provides real-time scoring and optimization suggestions for Google, Bing, and social media previews.

The SERP Simulator supports previewing 7 types of rich snippets that can appear in search results:

• FAQ Snippets — expandable question and answer dropdowns
• How-To Snippets — step-by-step instruction previews
• Recipe Snippets — cooking time, ratings, and ingredients
• Video Snippets — thumbnail, duration, and upload date
• Event Snippets — date, location, and ticket information
• Product Snippets — price, availability, and ratings
• Sitelink Snippets — additional page links beneath the main result

Configure your SERP preview using the input panels: Basic Info, Keywords, Media, Rich Snippets, SERP Features, and Advanced settings. Use the meta fetcher to auto-populate fields from any URL.

TruIntel runs automated tasks on a fixed schedule (all times in IST — Indian Standard Time):

TruIntel uses multiple AI models across the platform for different purposes:

The TruIntel Analytics App (app.truintel.ai) contains 68 distinct routes organized into the following categories. All pages are lazy-loaded with React.lazy() and Suspense for optimal performance.

The CMS module is integrated into the main TruIntel app under the /cms/* route prefix. It is protected by CMSProtectedRoute (requires authentication + CreditsProvider) and plan-gated behind the "cms" feature flag.