# Agent Analytics timeseries
Source: https://docs.siteline.ai/api-reference/agent-analytics/agent-analytics-timeseries

/reporting-api.openapi.json get /v1/products/{productId}/analytics/timeseries
Returns paginated AI agent / bot and referred human traffic timeseries. Use this endpoint for operational analytics, agent traffic dashboards, and data warehouse syncs.

Response rows include only the requested metrics and dimensions.



# Citations
Source: https://docs.siteline.ai/api-reference/citations/citations

/reporting-api.openapi.json get /v1/products/{productId}/citations
Returns citations from AI answers for a selected product by property, page or associated products.

When `groupBy` targets a single dimension (`property`, `page`, or `product`), the response includes only that top-level field. The aliases `byProperty`, `byPage`, and `byProduct` also work.



# List products
Source: https://docs.siteline.ai/api-reference/products/list-products

/reporting-api.openapi.json get /v1/products
Lists primary products authorized for the API key's team. Start here when you need product IDs for downstream calls. Competitor products linked through comparison data are excluded.



# List tracked websites
Source: https://docs.siteline.ai/api-reference/products/list-tracked-websites

/reporting-api.openapi.json get /v1/products/{productId}/websites
Lists website domains and IDs actively tracked in Agent Analytics for a product.



# AI visibility by product
Source: https://docs.siteline.ai/api-reference/prompts/ai-visibility-by-product

/reporting-api.openapi.json get /v1/products/{productId}/prompts/summary
Returns aggregate AI visibility by product across all prompts for the selected filters.



# AI visibility by prompt
Source: https://docs.siteline.ai/api-reference/prompts/ai-visibility-by-prompt

/reporting-api.openapi.json get /v1/products/{productId}/prompts
Returns one row with AI visibility metrics per tracked prompt, platform, and domain for the selected filters.

`position`, `visibility`, `rank`, and `runCount` can be `null` when no value is available for that prompt row.



# AI visibility timeseries
Source: https://docs.siteline.ai/api-reference/prompts/ai-visibility-timeseries

/reporting-api.openapi.json get /v1/products/{productId}/prompts/dates
Returns daily trend rows for prompt visibility, position, and rank for a product. Use this endpoint for timeseries charts and trends monitoring.



# Authorization
Source: https://docs.siteline.ai/authorization

Learn how to generate a Siteline website key

All Agent Analytics integrations and the direct HTTP endpoint use a "website key" bearer token authentication scheme for secure access to endpoints.

Each website key is unique to the website you are tracking. If you configure multiple website domains, you will have to manage multiple API keys.

You can create, view, and manage your websites and associated keys in the configuration section of the Agent Analytics feature within your workspace.

All API requests must be made over HTTPS to ensure secure transmission of your credentials.

## Get Your Website Key

Before setting up any integration, you'll need to obtain your Siteline website key:

<Steps>
  <Step title="Sign up for Siteline">
    Create a free [Siteline](https://siteline.ai) account if you haven't already.
  </Step>

  <Step title="Generate Website Key">
    Navigate to **Agent Analytics** and click **Generate Website Key**. Save this key securely - you'll need it for the integration setup.
  </Step>
</Steps>


# Azure CDN
Source: https://docs.siteline.ai/integrations/azure-cdn

Integrate Siteline with Azure CDN or Front Door diagnostic logs

Use the Siteline Azure CDN Log Processor to track Azure CDN or Front Door traffic with Siteline. This integration processes CDN diagnostic logs from Blob Storage, triggers on blob-created events via Event Grid, and forwards pageview events to the Siteline API — no application code changes required.

## Prerequisites

* A [Siteline website key](/authorization)
* An existing Azure CDN or Front Door profile
* Azure CLI configured for the target subscription
* Node.js 18+ and npm

<Info>
  Azure CDN diagnostic logs are batched hourly. Expect a **5–60 minute delay** between a CDN request and the pageview appearing in Siteline.
</Info>

## Setup

<Steps>
  <Step title="Clone and install">
    ```bash theme={null}
    git clone https://github.com/siteline-ai/siteline-azure-cdn.git
    cd siteline-azure-cdn
    npm install
    ```
  </Step>

  <Step title="Log in to Azure">
    ```bash theme={null}
    az login
    ```
  </Step>

  <Step title="Run the setup wizard">
    ```bash theme={null}
    npm run setup
    ```

    The interactive wizard will:

    * Prompt for your Siteline website key
    * List available CDN / Front Door profiles in your subscription
    * Provision all required Azure resources via Bicep (storage account, Function App, Event Grid subscription, diagnostic settings)
  </Step>
</Steps>

## How it works

This integration uses Diagnostic Settings, Blob Storage, Event Grid, and Azure Functions:

```text theme={null}
Azure CDN / Front Door (diagnostic logs)
  -> Blob Storage (cdn-logs container)
  -> Event Grid (BlobCreated)
  -> Azure Function (processor)
  -> Siteline intake API
```

Processing flow:

1. Azure CDN or Front Door writes hourly log batches to Blob Storage via Diagnostic Settings.
2. Blob Storage emits `BlobCreated` events to Event Grid.
3. Event Grid triggers the Azure Function processor.
4. The Function downloads and decompresses the log blob.
5. The Function parses records, normalizes fields across all CDN SKUs (Standard Microsoft, Standard/Premium Verizon, Front Door Standard/Premium), and sends pageview events to Siteline with 10 concurrent requests and 3 retries.

Failed events are routed to a dead-letter queue (`dlq` container) for inspection.

## Configuration

All settings are defined in `infra/main.bicepparam` and can be edited directly before running setup.

<ResponseField name="sitelineWebsiteKey" type="string">
  Your Siteline website key. Used to authenticate requests to the Siteline API.
</ResponseField>

<ResponseField name="cdnProfileResourceId" type="string">
  The full Azure resource ID of the target CDN or Front Door profile.
</ResponseField>

<ResponseField name="location" type="string">
  Azure deployment region. Defaults to `eastus`.
</ResponseField>

<ResponseField name="storageAccountName" type="string">
  Storage account name. Defaults to `sitelineazurecdnlogs`. Must be globally unique.
</ResponseField>

<ResponseField name="functionAppName" type="string">
  Function App name. Defaults to `siteline-azure-cdn-processor`.
</ResponseField>

<ResponseField name="logContainerName" type="string">
  Blob container name for CDN logs. Defaults to `cdn-logs`.
</ResponseField>

<ResponseField name="sitelineEndpoint" type="string">
  Siteline intake endpoint. Defaults to `https://api.siteline.ai/v1/intake/pageview`.
</ResponseField>

<ResponseField name="sitelineDebug" type="boolean">
  Enables verbose logging in the Function App. Defaults to `false`.
</ResponseField>

## Deploying updates

After initial setup, redeploy function code with:

```bash theme={null}
npm run deploy
```

This rebuilds, packages, and deploys the Function App interactively, prompting for resource group and function app with saved defaults.

## Troubleshooting

<AccordionGroup>
  <Accordion title="az: command not found">
    Install the [Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) and ensure it is available on your `PATH`.
  </Accordion>

  <Accordion title="No CDN profiles found">
    Verify you are logged into the correct Azure subscription. You can also enter the CDN profile resource ID manually when prompted.
  </Accordion>

  <Accordion title="Storage account name already taken">
    Storage account names are globally unique. Edit `storageAccountName` in `infra/main.bicepparam` with a unique name and rerun setup.
  </Accordion>

  <Accordion title="RBAC permission error during setup">
    Role assignments can take 1–2 minutes to propagate. Wait briefly and rerun `npm run setup` — Bicep deployments are idempotent.
  </Accordion>

  <Accordion title="LocationNotAvailableForResourceGroup with Global region">
    The setup wizard auto-resolves this. If it persists, specify a concrete region like `eastus` in the `location` parameter.
  </Accordion>

  <Accordion title="No pageviews appearing in Siteline">
    Diagnostic logs are batched hourly — wait up to 60 minutes after initial setup. If pageviews still don't appear, check the `dlq` blob container for failed events.
  </Accordion>

  <Accordion title="How do I change configuration after setup?">
    Edit parameters directly in `infra/main.bicepparam` and rerun `npm run setup`. The Bicep deployment is idempotent and will update resources in place.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Cloudflare
Source: https://docs.siteline.ai/integrations/cloudflare

Integrate Siteline with Cloudflare Workers

Use [Cloudflare Workers](https://developers.cloudflare.com/workers/) to intercept requests at the edge and forward server logs containing AI bot & agent visit data to Siteline. The worker runs outside your application's request path, so there's no impact on site performance and no Cloudflare data is modified in any way.

<Note>
  On a hosted website builder like Webflow, Framer, or HubSpot? See [Website Builders](/integrations/website-builders) for the full DNS-and-Worker setup.
</Note>

## Prerequisites

* A [Siteline website key](/authorization)
* A Cloudflare account with your domain configured
* [Node.js](https://nodejs.org/) installed locally

## Setup

<Info>
  Both Cloudflare's DNS proxy and Workers run on Cloudflare's **free tier** (100K Worker requests/day), which covers most sites.

  If you have higher traffic and wish to stay on the free tier you can [scope your Worker routes](https://developers.cloudflare.com/workers/configuration/routing/routes/) to only the subdomains or paths that matter (e.g. your marketing site and blog, not your app dashboard). See [Cloudflare Workers pricing](https://developers.cloudflare.com/workers/platform/pricing/) for details.
</Info>

<Steps>
  <Step title="Clone and install">
    ```bash theme={null}
    git clone https://github.com/siteline-ai/siteline-cloudflare-worker.git
    cd siteline-cloudflare-worker
    npm install
    ```
  </Step>

  <Step title="Log in to Cloudflare via Wrangler (official CLI tool)">
    * Trigger the login page

    ```bash theme={null}
    npx wrangler login
    ```

    * Allow Wrangler (Cloudflare's official command-line tool) to access your account
  </Step>

  <Step title="Set your website key">
    * Create an encrypted secret for your Siteline website key

    ```bash theme={null}
    npx wrangler secret put SITELINE_WEBSITE_KEY
    ```

    * Paste your key when prompted and press Enter
    * Enter `Y` when prompted if you want to create a new Worker with name `siteline-cloudflare-worker`
  </Step>

  <Step title="Deploy">
    ```bash theme={null}
    npm run deploy
    ```
  </Step>

  <Step title="Configure routes">
    * In the [Cloudflare Dashboard](https://dash.cloudflare.com/), navigate to **Compute & AI** > **Workers & Pages**

    * Select **siteline-cloudflare-worker** > **Settings** > **Domain & Routes** > **Add** > **Route**

    * Select your project as the Zone and enter a route for the domains you'd like to track:

      * `example.com/*` — tracks all *pages* for your domain
      * `*example.com/*` — tracks all *pages & subdomains*

      <Info>
        We recommend tracking all *content* pages. If your blog is configured as a subdomain, use `*example.com/*` to capture both subdomains and root pages.
      </Info>

    * Set **Failure Mode** to **Fail Open**

    * Save
  </Step>
</Steps>

## How it works

The worker runs as middleware on your domain:

1. Receives an incoming request
2. Forwards the request immediately to your origin (zero added latency)
3. Sends tracking data to Siteline in the background via `ctx.waitUntil`
4. Returns the response to the visitor unmodified

Static assets (images, CSS, JS, fonts) are automatically excluded.

View the full source on [GitHub](https://github.com/siteline-ai/siteline-cloudflare-worker).

## Environment variables

<ResponseField name="SITELINE_WEBSITE_KEY" type="string">
  Your Siteline website key. Set via `npx wrangler secret put SITELINE_WEBSITE_KEY`.
</ResponseField>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Worker not tracking visits">
    Verify that routes are configured in the Cloudflare Dashboard under **Compute & AI** > **Workers & Pages**. Select **siteline-cloudflare-worker** > **Settings** > **Domain** > **Routes.** You should see either `exampledomain.com/*` or `*exampledomain.com/*` configured as routes.
  </Accordion>

  <Accordion title="How do I check if my key is set?">
    Run `npx wrangler secret list` to confirm `SITELINE_WEBSITE_KEY` is present.
  </Accordion>

  <Accordion title="How do I view real-time logs?">
    Run `npx wrangler tail` to stream logs from your deployed worker.
  </Accordion>

  <Accordion title="How do I update my website key?">
    Run `npx wrangler secret put SITELINE_WEBSITE_KEY` and paste your new key when prompted.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# AWS CloudFront
Source: https://docs.siteline.ai/integrations/cloudfront

Integrate Siteline with CloudFront standard logs in S3

Use the Siteline AWS CloudFront S3 Log Processor to track CloudFront traffic with Siteline. This advanced/self-hosted integration processes CloudFront standard access logs from S3, triggers on S3 object-created events via EventBridge, and forwards pageview events to the Siteline API.

<Info>
  If you use Fastly, the recommended setup is the direct [Fastly HTTPS logging integration](/integrations/fastly). It avoids the AWS S3/EventBridge/Lambda path.
</Info>

## Prerequisites

* A [Siteline website key](/authorization)
* An existing CloudFront distribution configured to write **standard access logs** to S3
* AWS CLI v2 configured for the target account
* `jq` and `zip` installed locally
* Node.js 18+ and npm
* IAM permissions for `s3`, `lambda`, `iam`, and `events`

<Info>
  CloudFront standard logs are delayed by design. Typical availability is **5-15 minutes** after requests occur.
</Info>

## Setup

<Steps>
  <Step title="Clone and install">
    ```bash theme={null}
    git clone https://github.com/siteline-ai/siteline-cloudfront.git
    cd siteline-cloudfront
    npm install
    ```
  </Step>

  <Step title="Configure environment variables">
    ```bash theme={null}
    cp .env.example .env
    ```

    Set at minimum:

    * `SITELINE_WEBSITE_KEY`
    * `LOG_BUCKET_NAME`
    * `AWS_REGION`
    * `AWS_PROFILE` (if using SSO or non-default profile)
  </Step>

  <Step title="Build and package Lambda">
    ```bash theme={null}
    npm run package
    ```
  </Step>

  <Step title="Provision AWS resources">
    ```bash theme={null}
    npm run setup:all
    ```

    This runs:

    * `npm run setup:s3`
    * `npm run setup:lambda`
    * `npm run setup:eventbridge`
  </Step>

  <Step title="Point CloudFront logs to the configured bucket">
    In your CloudFront distribution settings, enable **standard access logs** and confirm logs are written to `LOG_BUCKET_NAME`.
  </Step>
</Steps>

## How it works

This integration uses S3 log delivery, EventBridge, and Lambda:

```text theme={null}
CloudFront (standard logs)
  -> S3 log bucket
  -> EventBridge (Object Created)
  -> Lambda s3-log-processor
  -> Siteline intake API
```

Processing flow:

1. CloudFront writes gzipped log files to S3.
2. S3 sends `Object Created` events to EventBridge.
3. EventBridge invokes the Lambda processor.
4. Lambda downloads and gunzips the log file.
5. Lambda parses the `#Fields` header dynamically, maps each valid row, and sends events to Siteline.

Rows with invalid status codes or missing URI are skipped. Malformed rows are skipped without stopping the rest of the file.

## Configuration

<ResponseField name="SITELINE_WEBSITE_KEY" type="string">
  Your Siteline website key. If missing, the Lambda exits without processing logs.
</ResponseField>

<ResponseField name="LOG_BUCKET_NAME" type="string">
  S3 bucket used for CloudFront standard logs. Lambda only reads objects from this bucket.
</ResponseField>

<ResponseField name="AWS_REGION" type="string">
  AWS region used by setup scripts and Lambda operations.
</ResponseField>

<ResponseField name="S3_BUCKET_REGION" type="string">
  Region override for S3 bucket operations. Defaults to `AWS_REGION`.
</ResponseField>

<ResponseField name="SITELINE_ENDPOINT" type="string">
  Siteline intake endpoint. Defaults to `https://api.siteline.ai/v1/intake/pageview`.
</ResponseField>

<ResponseField name="SITELINE_DEBUG" type="boolean">
  Enables debug mode in the Siteline SDK.
</ResponseField>

<ResponseField name="LAMBDA_FUNCTION_NAME" type="string">
  Lambda function name. Default is `siteline-cloudfront-s3-processor`.
</ResponseField>

<ResponseField name="EVENT_RULE_NAME" type="string">
  EventBridge rule name for S3 object-created events.
</ResponseField>

## Required IAM policies

Lambda trust policy:

```json theme={null}
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": ["lambda.amazonaws.com"]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

Lambda execution policy (bucket name is injected during setup):

```json theme={null}
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowCloudWatchLogs",
      "Effect": "Allow",
      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "arn:aws:logs:*:*:*"
    },
    {
      "Sid": "AllowReadCloudFrontLogsFromS3",
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::<LOG_BUCKET_NAME>/*"
    }
  ]
}
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="No Lambda invocations">
    Confirm CloudFront is writing standard logs to `LOG_BUCKET_NAME`, then verify S3 EventBridge notifications are enabled on that bucket.
  </Accordion>

  <Accordion title="No EventBridge to Lambda delivery">
    Check targets with:

    ```bash theme={null}
    aws events list-targets-by-rule --name "${EVENT_RULE_NAME}" --region "${AWS_REGION}"
    ```
  </Accordion>

  <Accordion title="AccessDenied errors during setup or runtime">
    Ensure deployer permissions include S3, IAM, Lambda, and EventBridge management. Also confirm Lambda execution role has `s3:GetObject` on the log bucket.
  </Accordion>

  <Accordion title="How do I inspect processor logs?">
    Stream CloudWatch logs with:

    ```bash theme={null}
    aws logs tail "/aws/lambda/${LAMBDA_FUNCTION_NAME}" --follow --region "${AWS_REGION}"
    ```
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Fastly
Source: https://docs.siteline.ai/integrations/fastly

Forward Fastly HTTPS logs to Siteline

Use Fastly HTTPS logging to stream CDN request logs directly to Siteline Agent Analytics. This setup is manual: you create the Fastly logging endpoint in your Fastly account and use your Siteline website secret key to identify the incoming traffic.

No AWS, S3, EventBridge, Lambda, IAM setup, zip files, CLI scripts, or Fastly API token in Siteline is required.

## Prerequisites

* A Siteline website in **Settings** > **Connected Websites**
* The website secret key for that Siteline website
* Admin or engineer access to the Fastly service that serves your website
* Permission to clone, edit, validate, and activate a Fastly service version

<Info>
  Treat the website secret key like a password. Anyone with this key can submit analytics events for that website.
</Info>

## Setup

<Steps>
  <Step title="Copy your website secret key">
    In Siteline, go to **Settings** > **Connected Websites**, find the website you want to connect, and copy its **Website Secret Key**.
  </Step>

  <Step title="Open your Fastly service">
    In the Fastly dashboard, open the service that serves the same website.
  </Step>

  <Step title="Clone the active version">
    Open **Service configuration**, select the active version, and clone it so you can edit a draft version.
  </Step>

  <Step title="Add an HTTPS logging endpoint">
    In the draft service version, open **Logging** and add an **HTTPS** logging endpoint.
  </Step>

  <Step title="Enter the Siteline endpoint settings">
    Use the settings in the table below. Replace `YOUR_SITELINE_WEBSITE_KEY` with the website secret key you copied from Siteline.
  </Step>

  <Step title="Validate and activate">
    Validate the draft Fastly version. When you are ready for the production service to send logs to Siteline, activate the version.
  </Step>
</Steps>

## Fastly HTTPS logging settings

| Setting               | Value                                                                                                                                                                                                                                                                                                                                                                                                             |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Name                  | `siteline-traffic`                                                                                                                                                                                                                                                                                                                                                                                                |
| URL                   | `https://api.siteline.ai/v1/intake/fastly`                                                                                                                                                                                                                                                                                                                                                                        |
| Method                | `POST`                                                                                                                                                                                                                                                                                                                                                                                                            |
| Content type          | `application/json`                                                                                                                                                                                                                                                                                                                                                                                                |
| Header name           | `Authorization`                                                                                                                                                                                                                                                                                                                                                                                                   |
| Header value          | `Bearer YOUR_SITELINE_WEBSITE_KEY`                                                                                                                                                                                                                                                                                                                                                                                |
| Period                | `5`                                                                                                                                                                                                                                                                                                                                                                                                               |
| Request max bytes     | `1900000`                                                                                                                                                                                                                                                                                                                                                                                                         |
| Log processing region | `none`                                                                                                                                                                                                                                                                                                                                                                                                            |
| Log format            | `{"timestamp":"%{begin:%Y-%m-%dT%H:%M:%SZ}t","host":"%{json.escape(req.http.host)}V","url":"%{json.escape(req.url)}V","request_method":"%m","response_status":%s,"time_elapsed_usec":%{time.elapsed.usec}V,"request_user_agent":"%{json.escape(req.http.User-Agent)}V","request_referer":"%{json.escape(req.http.Referer)}V","client_ip":"%h","service_id":"%{req.service_id}V","version":"%{req.vcl.version}V"}` |

The Fastly HTTPS logging API documents these fields, including `header_name`, `header_value`, `request_max_bytes`, and `period`: [Fastly HTTPS logging reference](https://www.fastly.com/documentation/reference/api/logging/https/).

## How it works

Fastly sends batches of JSON request records to Siteline:

```text theme={null}
Fastly HTTPS logging
  -> https://api.siteline.ai/v1/intake/fastly
  -> Siteline analytics pipeline
```

When you validate the Fastly HTTPS logging endpoint, Siteline automatically answers Fastly's domain-control challenge for the shared `api.siteline.ai` endpoint.

Siteline reads the `Authorization: Bearer <website secret key>` header, parses each row, skips malformed rows, and maps valid records to Agent Analytics pageviews for the matching website.

## Verify the setup

After you activate the Fastly version, visit your website and wait a short time for Fastly to deliver its next batch. Then refresh Siteline Agent Analytics.

You should see the website integration type become **Fastly** after Siteline receives valid events.

## Disconnect

To stop sending Fastly logs to Siteline, remove or disable the `siteline-traffic` HTTPS logging endpoint in Fastly and activate the updated service version.

If the website secret key may have been exposed, regenerate it in **Settings** > **Connected Websites**. After regenerating the key, update the Fastly HTTPS logging header value to use the new key.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Fastly validation fails">
    Confirm the URL is `https://api.siteline.ai/v1/intake/fastly`, the method is `POST`, and the content type is `application/json`. Fastly HTTPS logging destinations must use HTTPS.
  </Accordion>

  <Accordion title="No traffic appears in Siteline">
    Confirm the `Authorization` header value is `Bearer YOUR_SITELINE_WEBSITE_KEY`, not your Fastly API token. Visit the website after activation and allow time for Fastly's next log batch.
  </Accordion>

  <Accordion title="Events are attached to the wrong website">
    Check that the Fastly header uses the website secret key for the Siteline website you intended to connect.
  </Accordion>

  <Accordion title="You regenerated the website secret key">
    Update the Fastly HTTPS logging endpoint header value to use `Bearer <new website secret key>`, then validate and activate the Fastly version.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Direct HTTP API
Source: https://docs.siteline.ai/integrations/http-api

Integrate Siteline via HTTP API

Send bot visit data to Siteline from any backend using a JSON POST request. Use this integration when you need full control over tracking or your stack isn't covered by one of the platform-specific integrations.

## Prerequisites

* A [Siteline website key](/authorization)
* A backend capable of making outbound HTTP requests

## Endpoint

```shellscript theme={null}
POST https://api.siteline.ai/v1/intake/pageview
```

Only POST requests with a JSON body are supported. Requests must be made over HTTPS.

## Body parameters

<ResponseField name="url" type="string">
  The full URL of the page being accessed (e.g. `https://yoursite.com/blog/post`).
</ResponseField>

<ResponseField name="userAgent" type="string">
  The `User-Agent` header from the incoming request.
</ResponseField>

<ResponseField name="ref" type="string">
  The `Referer` header from the incoming request.
</ResponseField>

<ResponseField name="ip" type="string">
  The visitor's IP address.
</ResponseField>

<ResponseField name="websiteKey" type="string">
  Your Siteline website key.
</ResponseField>

## Example

```bash theme={null}
curl --request POST \
  "https://api.siteline.ai/v1/intake/pageview" \
  --header "Content-Type: application/json" \
  --data '{
    "url": "https://yoursite.com/blog/post",
    "userAgent": "Mozilla/5.0 (compatible; ChatGPT-User/1.0)",
    "ref": "https://referrer.example",
    "ip": "1.2.3.4",
    "websiteKey": "secret_key_..."
  }'
```

## Best practices

* **Track key pages only** — blogs, landing pages, product pages, `robots.txt`, `sitemap.xml`
* **Skip static assets** — images, CSS, JS, fonts don't need to be tracked
* **Fire-and-forget** — don't await the response; send tracking calls asynchronously for zero impact on site speed
* **Keep sensitive fields out of URLs** — send `websiteKey` and IP data only in the JSON body

## Troubleshooting

<AccordionGroup>
  <Accordion title="Requests not appearing in Agent Analytics">
    Verify that all required body fields are present. Check that your `websiteKey` is correct and that the request includes `Content-Type: application/json`.
  </Accordion>

  <Accordion title="Where do I find my website key?">
    Navigate to **Agent Analytics** in your Siteline workspace and click **Manage Configuration** to view or regenerate your key.
  </Accordion>

  <Accordion title="Should I track every request?">
    No. Focus on content pages that AI bots are likely to crawl. Exclude static assets and internal API routes.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Netlify
Source: https://docs.siteline.ai/integrations/netlify

Integrate Siteline with Netlify Edge Functions

Use a [Netlify Edge Function](https://docs.netlify.com/edge-functions/overview/) to intercept requests at the edge and forward tracking data to Siteline using the `@siteline/core` SDK. The edge function proxies the request transparently, so there is zero impact on site performance.

## Prerequisites

* A [Siteline website key](/authorization)
* A Netlify site with [Edge Functions](https://docs.netlify.com/edge-functions/overview/) enabled

<Info>
  Netlify Edge Functions are available on all plans, including the **free tier**. See [Netlify Edge Functions](https://docs.netlify.com/edge-functions/overview/) for details.
</Info>

## Setup

<Steps>
  <Step title="Add the edge function">
    Create an `edge-functions` directory in the root of your Netlify project and copy [`siteline.ts`](https://github.com/siteline-ai/siteline-js-sdk/blob/main/examples/netlify/edge-functions/siteline.ts) into it:

    ```
    your-project/
    ├── edge-functions/
    │   └── siteline.ts
    └── netlify.toml
    ```

    The function imports `@siteline/core` via an ESM URL (`https://esm.sh/@siteline/core@1.0.9`) — no `npm install` is needed since Netlify Edge Functions run on Deno.
  </Step>

  <Step title="Set your website key">
    Open `edge-functions/siteline.ts` and set the `SITELINE_WEBSITE_KEY` constant at the top of the file:

    ```typescript theme={null}
    const SITELINE_WEBSITE_KEY = 'secret_key_...';
    ```

    Optionally configure `SITELINE_ENDPOINT` and `SITELINE_DEBUG`.
  </Step>

  <Step title="Configure Netlify routes">
    Create or update `netlify.toml` in your project root:

    ```toml netlify.toml theme={null}
    [build]
      edge_functions = "edge-functions"

    [[edge_functions]]
      path = "/*"
      function = "siteline"
    ```

    This routes every incoming request through the Siteline edge function.
  </Step>

  <Step title="Deploy">
    Deploy your site as usual. The edge function will begin tracking requests immediately.
  </Step>
</Steps>

## How it works

The edge function runs as middleware on every matched request:

1. A visitor (or AI bot) makes a request to your Netlify site
2. The edge function calls `context.next()` to forward the request to your origin
3. Tracking data (`url`, `method`, `status`, `duration`, `userAgent`, `ref`, `ip`, `acceptHeader`) is sent to Siteline asynchronously via fire-and-forget
4. The response is returned to the visitor unmodified

If the downstream request fails, the function still tracks the request with status `500` before re-throwing the error. The SDK initializes lazily on the first request and reuses the instance for subsequent calls.

View the full source on [GitHub](https://github.com/siteline-ai/siteline-js-sdk/blob/main/examples/netlify/edge-functions/siteline.ts).

## Configuration

<ResponseField name="SITELINE_WEBSITE_KEY" type="string">
  Your Siteline website key. If empty, tracking is disabled and a warning is logged to the console.
</ResponseField>

<ResponseField name="SITELINE_ENDPOINT" type="string">
  Siteline intake endpoint. Defaults to `https://api.siteline.ai/v1/intake/pageview`.
</ResponseField>

<ResponseField name="SITELINE_DEBUG" type="boolean">
  Enables debug logging. When `true`, errors in the edge function are logged to the console.
</ResponseField>

## Troubleshooting

<AccordionGroup>
  <Accordion title="No visits appearing in Siteline">
    Verify `SITELINE_WEBSITE_KEY` is set to a valid key in `edge-functions/siteline.ts`. Confirm `netlify.toml` routes `/*` to `function = "siteline"`.
  </Accordion>

  <Accordion title="Edge function does not run on requests">
    Ensure `[build] edge_functions = "edge-functions"` is present in `netlify.toml` and that the file exists at `edge-functions/siteline.ts`.
  </Accordion>

  <Accordion title="Will this slow down my site?">
    No. Tracking is fire-and-forget — the tracking call is not awaited and never blocks the response.
  </Accordion>

  <Accordion title="Do I need to install any npm packages?">
    No. The edge function imports `@siteline/core` via an ESM URL, which Netlify's Deno-based runtime resolves automatically.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Next.js
Source: https://docs.siteline.ai/integrations/nextjs

Integrate Siteline with Next.js

Use the [`@siteline/nextjs`](https://www.npmjs.com/package/@siteline/nextjs) package to track AI bot visits on your Next.js site. The tracker runs in a fire-and-forget pattern inside Next.js proxy code — requests are not awaited, so there is zero impact on page load times.

## Prerequisites

* A [Siteline website key](/authorization)
* A Next.js project using the [App Router](https://nextjs.org/docs/app) or [Pages Router](https://nextjs.org/docs/pages)

## Setup

<Steps>
  <Step title="Install the package">
    ```bash theme={null}
    npm install @siteline/nextjs
    ```
  </Step>

  <Step title="Add the proxy">
    Create or update your `proxy.ts` file in the root of your project:

    ```typescript proxy.ts theme={null}
    import { withSiteline } from "@siteline/nextjs";

    export default withSiteline({
      websiteKey: process.env.SITELINE_WEBSITE_KEY!,
    });

    export const config = {
      matcher: [
        "/robots.txt",
        "/sitemap.xml",
        "/((?!api|_next/static|_next/image|favicon.ico).*)",
      ],
    };
    ```
  </Step>

  <Step title="Deploy">
    Deploy your application as usual. The proxy will begin tracking AI bot visits immediately.
  </Step>
</Steps>

## How it works

The package hooks into [Next.js proxy](https://nextjs.org/docs/app/api-reference/file-conventions/proxy), which runs on every matched request before the page renders:

1. A visitor (or AI bot) makes a request to your Next.js site
2. The proxy extracts bot-relevant metadata (URL, user agent, IP, referrer)
3. Tracking data is sent to Siteline asynchronously — the request is not awaited
4. The page response is returned to the visitor unmodified

Static assets (`_next/static`, `_next/image`, `favicon.ico`) are excluded via the route matcher.

## Custom Proxy Logic

If you already have proxy logic, pass it as the second argument to `withSiteline`:

```typescript proxy.ts theme={null}
import { type SitelineConfig, withSiteline } from '@siteline/nextjs';
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

const sitelineConfig: SitelineConfig = {
  websiteKey: process.env.SITELINE_WEBSITE_KEY!,
  debug: process.env.NODE_ENV === 'development',
};

export default withSiteline(sitelineConfig, (request: NextRequest) => {
  const response = NextResponse.next();
  response.headers.set('x-custom-header', 'value');
  return response;
});

export const config = {
  matcher: ['/robots.txt', '/sitemap.xml', '/((?!api|_next/static|_next/image|favicon.ico).*)'],
};
```

## Configuration

<ResponseField name="websiteKey" type="string">
  Your Siteline website key. Found under **Agent Analytics** > **Manage Configuration** in your Siteline workspace. You can pass it directly or set it with the `SITELINE_WEBSITE_KEY` environment variable.
</ResponseField>

<ResponseField name="endpoint" type="string">
  Custom Siteline intake endpoint. Most sites can omit this.
</ResponseField>

<ResponseField name="debug" type="boolean">
  Enables debug logging. Use this only while developing or troubleshooting.
</ResponseField>

<ResponseField name="matcher" type="string[]">
  Next.js route matcher config. The example pattern excludes API routes and static assets. Adjust to
  match the routes you want to track.
</ResponseField>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Proxy not tracking visits">
    Ensure `proxy.ts` is in the root of your project (next to `package.json`), not inside `src/` or
    `app/`. Next.js picks up proxy files from the project root.
  </Accordion>

  <Accordion title="Where do I find my website key?">
    Navigate to **Agent Analytics** in your Siteline workspace and click **Manage Configuration** to
    view or regenerate your key.
  </Accordion>

  <Accordion title="I already have proxy logic — will this conflict?">
    No. Pass your existing logic as the second argument to `withSiteline`. It runs asynchronously
    and returns your response unchanged.
  </Accordion>

  <Accordion title="Will this slow down my site?">
    No. The tracking call is fire-and-forget — it is not awaited and never blocks the response. All
    errors are silently caught.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you
  through it.
</Tip>


# Vercel
Source: https://docs.siteline.ai/integrations/vercel

Integrate Siteline with Vercel Log Drains

Use [Vercel Log Drains](https://vercel.com/docs/observability/log-drains) to forward server-side request logs directly to Siteline. No code changes required — configuration is done entirely through the Vercel dashboard. Log drains run outside your application's request path, so there is zero impact on site performance.

## Prerequisites

* A [Siteline website key](/authorization)
* A Vercel account with your project deployed

<Info>
  Log Drains are available on Vercel's **Pro** and **Enterprise** plans. See [Vercel Drains pricing](https://vercel.com/docs/drains#usage-and-pricing) for details.
</Info>

## Setup

<Steps>
  <Step title="Open Log Drains settings">
    In the [Vercel Dashboard](https://vercel.com/dashboard), navigate to your project's **Settings** > **Log Drains** and click **Add Log Drain**.
  </Step>

  <Step title="Select drain type">
    Choose **Custom HTTP Endpoint** as the drain type.

    <img alt="Add drain" />
  </Step>

  <Step title="Select data sources">
    Select **Logs** as the data to drain.

    <img alt="Select logs" />
  </Step>

  <Step title="Configure the drain">
    Fill in the following fields:

    * **Drain Name**: `Siteline Agent Analytics`
    * **Projects**: Select your website project
    * **Sources**: Select all except `Builds`
    * **Environment**: `Production`
    * **Sampling Rate**: `100%`
  </Step>

  <Step title="Set the endpoint URL">
    Enter the following URL, replacing the placeholder with your Siteline website key:

    ```
    https://api.siteline.ai/v1/intake/vercel-log-drain?websiteKey=YOUR_WEBSITE_KEY
    ```
  </Step>

  <Step title="Save">
    Click **Create Drain** to activate. Vercel will begin forwarding logs immediately.
  </Step>
</Steps>

## How it works

Vercel Log Drains stream server-side request logs to an external HTTP endpoint in real time:

1. AI agents, bots or humans make requests to your Vercel-hosted site
2. Vercel processes the request and generates a log entry
3. The log entry is forwarded to the Siteline intake endpoint in the background
4. Siteline identifies AI agent visits and human referral traffic and surfaces it in your Agent Analytics dashboard

Your website's response time is unaffected — log drains operate asynchronously after the response is sent.

## Endpoint parameters

<ResponseField name="websiteKey" type="string">
  Your Siteline website key, passed as a query parameter in the endpoint URL.
</ResponseField>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Log drain not sending data">
    Verify the drain is active in **Settings** > **Log Drains**. Check that the endpoint URL includes your website key and that the drain status shows **Active**.
  </Accordion>

  <Accordion title="Only seeing some requests">
    Ensure **Sampling Rate** is set to `100%` and that `Builds` is the only source excluded.
  </Accordion>

  <Accordion title="How do I find my website key?">
    Navigate to **Agent Analytics** in your Siteline workspace and click **Manage Configuration** to view or regenerate your key.
  </Accordion>

  <Accordion title="How do I update the endpoint URL?">
    In **Settings** > **Log Drains**, delete the existing drain and create a new one with the updated URL.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Website Builders
Source: https://docs.siteline.ai/integrations/website-builders

Track AI bot & agent traffic on Webflow, Framer, HubSpot and other hosted website builders

Run Siteline on closed website builders — including [Webflow](#webflow), [Framer](#framer), [HubSpot](#hubspot) and similar hosted platforms — by routing traffic through [Cloudflare](https://cloudflare.com) and deploying the Siteline Cloudflare Worker on the edge.

## Why this approach?

Hosted website builders don't expose server logs or let you deploy custom middleware. A frontend JavaScript snippet won't capture AI traffic because most AI bots and agents don't execute JavaScript, measurement has to happen **server-side**.

Putting Cloudflare in front of your builder inserts a server-side measurement layer that these platforms don't natively provide. The Worker runs at the edge, forwards every request to your builder's origin with zero added latency, and asynchronously logs request metadata to Siteline.

You also get bot management, WAF rules, and easy subdomain hosting as bonus benefits.

## How it works

```mermaid actions={false} theme={null}
flowchart LR
    A[Visitor / AI bot] <--> CF[Cloudflare] <--> O[Your site<br/>Webflow, Framer, etc.]
    CF -. Worker .-> S[Siteline Agent Analytics]

    classDef cf fill:#F6821F,stroke:#C45A12,color:#fff;
    classDef sl fill:#0D9373,stroke:#0A6F58,color:#fff;
    class CF cf;
    class S sl;
```

Visitors and AI bots & agents now pass through Cloudflare before reaching your site, exactly as before. On the side, the Siteline Worker logs each request to Siteline asynchronously, your site's response is never delayed or modified.

## Prerequisites

* A [Siteline website key](/authorization)
* A Cloudflare account (free tier is sufficient)
* Admin access to your website builder and to your domain's DNS

## Setup

### 1. Add your domain to Cloudflare

<Steps>
  <Step title="Add the site in Cloudflare">
    In the [Cloudflare Dashboard](https://dash.cloudflare.com/), click **Add a domain** and enter your domain (e.g. `example.com`). Choose the **Free** plan.
  </Step>

  <Step title="Update nameservers at your registrar">
    Cloudflare will display two nameservers (e.g. `ari.ns.cloudflare.com`). Replace your domain's existing nameservers with these at your registrar (GoDaddy, Namecheap, Google Domains, etc.). Propagation typically takes a few minutes to a few hours.
  </Step>

  <Step title="Set SSL/TLS mode to Full">
    In Cloudflare go to **SSL/TLS** > **Overview** and set the encryption mode to **Full** (or **Full (strict)**). This ensures the connection from Cloudflare to your builder's origin uses HTTPS, which is required by Webflow, Framer, and HubSpot.
  </Step>
</Steps>

### 2. Configure your website builder

Add your custom domain inside your website builder's dashboard, then create matching DNS records in Cloudflare with the **proxy enabled** (orange cloud).

<Tabs>
  <Tab title="Webflow">
    <Steps>
      <Step title="Add the domain in Webflow">
        In Webflow, open your project and go to **Site settings** > **Publishing** > **Production**. Click **Add a custom domain** and enter your domain. Webflow will display the exact A record IP(s) and CNAME target you need.
      </Step>

      <Step title="Add the records in Cloudflare">
        In Cloudflare go to **DNS** > **Records** and add the records Webflow gave you:

        * **A** record on `@` pointing to Webflow's published IP
        * **CNAME** record on `www` pointing to `cdn.webflow.com`
        * Set **Proxy status** to **Proxied** (orange cloud) on both
      </Step>

      <Step title="Publish in Webflow">
        Back in Webflow, click **Check status** next to your domain, then publish your site. SSL is provisioned automatically.
      </Step>
    </Steps>

    <Warning>
      Always copy the IP and CNAME values directly from Webflow's dashboard — Webflow updates these periodically (most recently in 2026 as part of their Cloudflare migration). Hard-coded values from older guides may be stale.
    </Warning>

    Reference: [Webflow — Manually connect a custom domain](https://help.webflow.com/hc/en-us/articles/33961239562387-Manually-connect-a-custom-domain).
  </Tab>

  <Tab title="Framer">
    <Steps>
      <Step title="Connect the domain in Framer">
        In Framer, open your project and go to **Site Settings** > **Domains** > **Connect Custom Domain**. Enter your domain. Framer will display the A record IPs and CNAME target you need.
      </Step>

      <Step title="Add the records in Cloudflare">
        In Cloudflare go to **DNS** > **Records** and add the records Framer gave you:

        * **A** records on `@` pointing to each Framer IP
        * **CNAME** record on `www` pointing to `sites.framer.app`
        * Set **Proxy status** to **Proxied** (orange cloud) on all
      </Step>

      <Step title="Verify in Framer">
        Back in Framer, click **Check** next to your domain. Once verified, Framer provisions SSL automatically and your site is live.
      </Step>
    </Steps>

    <Warning>
      Framer occasionally rotates their published IP addresses. Always copy values directly from Framer's dashboard rather than relying on cached values from guides.
    </Warning>

    Reference: [Framer — Connect to hosting](https://www.framer.com/help/articles/connect-to-our-new-and-improved-hosting/).
  </Tab>

  <Tab title="HubSpot">
    <Steps>
      <Step title="Connect the domain in HubSpot">
        In HubSpot, navigate to **Settings** > **Content** > **Domains & URLs** > **Connect a domain**. Choose the content type (Website Pages, Landing Pages, Blog) and follow the prompts. HubSpot will display a **Required Data** value — typically a CNAME target like `[id].sites.hubspot.com`.
      </Step>

      <Step title="Add the CNAME record in Cloudflare">
        In Cloudflare go to **DNS** > **Records** > **Add record**:

        * **Type**: `CNAME`
        * **Name**: the subdomain you're connecting (e.g. `www` or `@` for the root)
        * **Target**: the value HubSpot provided
        * **Proxy status**: **Proxied** (orange cloud)
      </Step>

      <Step title="Verify in HubSpot">
        Click **Verify** in HubSpot. DNS propagation typically completes in 15–80 minutes. HubSpot will provision SSL automatically once verified.
      </Step>
    </Steps>

    <Note>
      Cloudflare's [CNAME flattening](https://developers.cloudflare.com/dns/cname-flattening/) automatically handles CNAMEs at the apex (root) domain — no special configuration required.
    </Note>

    Reference: [HubSpot — Connect your domain](https://knowledge.hubspot.com/domains-and-urls/connect-a-domain-to-hubspot).
  </Tab>

  <Tab title="Other (Squarespace, Wix, Shopify, ...)">
    The same pattern works for any builder that supports a custom domain via DNS:

    1. In your builder, add the custom domain and copy the DNS records it requires (A records, CNAME, or both).
    2. In Cloudflare, create matching records under **DNS** > **Records**.
    3. Set **Proxy status** to **Proxied** (orange cloud) on each.
    4. Verify the domain in your builder.

    If you're not sure whether your builder is compatible, [book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll confirm.
  </Tab>
</Tabs>

### 3. Deploy the Siteline Worker in Cloudflare

<Info>
  Both Cloudflare's DNS proxy and Workers run on Cloudflare's **free tier** (100K Worker requests/day), which covers most sites.

  If you have higher traffic and wish to stay on the free tier you can [scope your Worker routes](https://developers.cloudflare.com/workers/configuration/routing/routes/) to only the subdomains or paths that matter (e.g. your marketing site and blog, not your app dashboard). See [Cloudflare Workers pricing](https://developers.cloudflare.com/workers/platform/pricing/) for details.
</Info>

<Steps>
  <Step title="Clone and install">
    ```bash theme={null}
    git clone https://github.com/siteline-ai/siteline-cloudflare-worker.git
    cd siteline-cloudflare-worker
    npm install
    ```
  </Step>

  <Step title="Log in to Cloudflare via Wrangler (official CLI tool)">
    * Trigger the login page

    ```bash theme={null}
    npx wrangler login
    ```

    * Allow Wrangler (Cloudflare's official command-line tool) to access your account
  </Step>

  <Step title="Set your website key">
    * Create an encrypted secret for your Siteline website key

    ```bash theme={null}
    npx wrangler secret put SITELINE_WEBSITE_KEY
    ```

    * Paste your key when prompted and press Enter
    * Enter `Y` when prompted if you want to create a new Worker with name `siteline-cloudflare-worker`
  </Step>

  <Step title="Deploy">
    ```bash theme={null}
    npm run deploy
    ```
  </Step>

  <Step title="Configure routes">
    * In the [Cloudflare Dashboard](https://dash.cloudflare.com/), navigate to **Compute & AI** > **Workers & Pages**

    * Select **siteline-cloudflare-worker** > **Settings** > **Domain & Routes** > **Add** > **Route**

    * Select your project as the Zone and enter a route for the domains you'd like to track:

      * `example.com/*` — tracks all *pages* for your domain
      * `*example.com/*` — tracks all *pages & subdomains*

      <Info>
        We recommend tracking all *content* pages. If your blog is configured as a subdomain, use `*example.com/*` to capture both subdomains and root pages.
      </Info>

    * Set **Failure Mode** to **Fail Open**

    * Save
  </Step>
</Steps>

### 4. Verify

After the Worker is deployed and routes are configured, visit your site (or `curl` it) and check **Agent Analytics** in your [Siteline workspace](https://siteline.ai/app). You should see traffic appear within a few seconds. AI bot visits will be classified automatically.

## Bonus benefits

Putting Cloudflare in front of your builder unlocks several useful capabilities:

* **Bot management & WAF rules** — block or rate-limit unwanted crawlers without changing your builder configuration
* **Subdomain hosting** — route `blog.example.com`, `docs.example.com`, etc. to different origins via Cloudflare
* **Edge caching** — cache static assets at Cloudflare's edge for faster page loads
* **Analytics** — see request volume, cache hit rate, and threat data in the Cloudflare dashboard

## Troubleshooting

<AccordionGroup>
  <Accordion title="My site shows a 525 or 526 SSL error after switching to Cloudflare">
    Set Cloudflare's SSL/TLS mode to **Full** under **SSL/TLS** > **Overview**. The default ("Flexible") doesn't work with Webflow, Framer, or HubSpot because they require HTTPS on the origin connection.
  </Accordion>

  <Accordion title="Builder dashboard says my domain is not verified">
    Double-check that the DNS record values in Cloudflare exactly match what your builder asked for. Then wait 15–80 minutes for propagation. You can verify propagation at [dnschecker.org](https://dnschecker.org).
  </Accordion>

  <Accordion title="Worker isn't logging visits">
    In Cloudflare, go to **Workers & Pages** > **siteline-cloudflare-worker** > **Settings** > **Domain & Routes** and confirm a route like `example.com/*` or `*example.com/*` is configured. Then run `npx wrangler tail` from the cloned repo to stream real-time logs from the Worker.
  </Accordion>

  <Accordion title="Too many redirects error">
    This usually means Cloudflare's SSL mode is set to **Flexible** while your builder is forcing HTTPS. Switch to **Full** in **SSL/TLS** > **Overview**.
  </Accordion>

  <Accordion title="How do I update my Siteline website key later?">
    Run `npx wrangler secret put SITELINE_WEBSITE_KEY` from the cloned repo and paste the new key when prompted. No redeploy required.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it for your specific builder.
</Tip>


# WordPress
Source: https://docs.siteline.ai/integrations/wordpress

Integrate Siteline with WordPress

Install the [Siteline Agent Analytics](https://wordpress.org/plugins/siteline-agent-analytics/) plugin to track AI bot visits on your WordPress site. No code required — the plugin runs in fire-and-forget mode inside WordPress hooks, so there is zero impact on page load times.

## Prerequisites

* A [Siteline website key](/authorization)
* Administrator access to your WordPress site
* Ability to install plugins on your WordPress installation

## Setup

<Steps>
  <Step title="Open the Plugins panel">
    Navigate to your WordPress admin panel at `https://yoursite.com/wp-admin` and click **Plugins** in the left sidebar.
  </Step>

  <Step title="Search and install">
    Search for [Siteline Agent Analytics](https://wordpress.org/plugins/siteline-agent-analytics/) in the Plugins search bar, then click **Install Now**.
  </Step>

  <Step title="Activate">
    Back in the Plugins list, click **Activate** under the Siteline Agent Analytics plugin.
  </Step>

  <Step title="Configure">
    Go to **Settings** > **Siteline** in the left sidebar and configure:

    * **Enable Tracking**: Leave checked (uncheck to pause tracking)
    * **Website ID**: Paste your Siteline website key from [siteline.ai](https://siteline.ai)

    Click **Save Changes** to apply.
  </Step>

  <Step title="Enable auto-updates (recommended)">
    On the Plugins page, enable auto-updates for Siteline to stay up to date automatically.
  </Step>
</Steps>

## How it works

The plugin hooks into WordPress request processing:

1. A visitor (or AI bot) makes a request to your WordPress site
2. The plugin detects the request and extracts bot-relevant metadata (URL, user agent, IP, referrer)
3. Tracking data is sent to Siteline asynchronously in a fire-and-forget pattern
4. The page response is returned to the visitor unmodified

Errors are silently caught and discarded — the plugin never interferes with your site's normal operation.

## Plugin settings

<ResponseField name="Enable Tracking" type="boolean">
  Toggle AI bot tracking on or off. Checked by default.
</ResponseField>

<ResponseField name="Website ID" type="string">
  Your Siteline website key. Found under **Agent Analytics** > **Manage Configuration** in your Siteline workspace.
</ResponseField>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Plugin not tracking visits">
    Verify that **Enable Tracking** is checked in **Settings** > **Siteline** and that your Website ID is entered correctly.
  </Accordion>

  <Accordion title="Where do I find my Website ID?">
    Navigate to **Agent Analytics** in your Siteline workspace and click **Manage Configuration** to view or regenerate your website key, then paste it into the plugin's **Website ID** field.
  </Accordion>

  <Accordion title="How do I update the plugin?">
    If auto-updates are enabled, the plugin updates automatically. Otherwise, go to **Plugins**, find Siteline, and click **Update Now** when available.
  </Accordion>

  <Accordion title="Will the plugin slow down my site?">
    No. The plugin sends tracking data asynchronously and never blocks page rendering. All errors are silently caught.
  </Accordion>
</AccordionGroup>

<Tip>
  **Need help?** [Book a setup call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Introduction
Source: https://docs.siteline.ai/introduction

Growth analytics for the agentic web

[Siteline](https://siteline.ai/app) turns AI bot and agent traffic into actionable insights to improve AI search visibility and drive organic growth.

## Why track AI bot & agent traffic?

AI bots and agents from OpenAI, Google, Anthropic and others regularly crawl your website to reasearch your products, verify information and report back to humans. Understanding their intentions, actions and potential blockers is essential for improving AI visbility and preparing for the future of organic growth where humans are not the only customer.

## Key features

Siteline has two core parts:

* [**Agent Analytics**](/integrations/vercel) - Monitor AI agents, bots and crawlers ingesting your content in real-time. Understand where they're getting stuck, identify trending topics and optimize their experience to boost your AI visibility.
* [**Visibility Tracking**](/metrics-glossary) - Track your brand or product's visibility against competitors, check the sources AI cites and identify top areas of opportunity.

## Get started with Agent Analytics

Most AI bots bypass JavaScript, so they don't show up in tools like Google Analytics - they need to be tracked server-side. We offer nine easy to integrate and secure options:

<CardGroup>
  <Card title="Cloudflare" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100" height="20" width="20"><g clipPath="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#a)"><mask id="b" width="100" height="100" x="0" y="0" maskUnits="userSpaceOnUse" style={{maskType:"luminance"}}><path fill="#fff" d="M100 0H0v100h100z"/></mask><g mask="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#b)"><path fill="#fff" d="m79 46.3-2-.8c-9.8 21.9-48.5 8.6-50.9 15.1-.4 4.4 21.2.8 36.6 1.6 4.7.2 7.1 3.8 5.1 9.6h3.9c4.5-14.1 19-6.9 19.6-11.6-1-3.1-16.6 0-12.3-13.9"/><path fill="#999" d="M68.9 69.3c.6-2.1.4-4.1-.6-5.4-1-1.2-2.5-2.1-4.4-2.3l-36.1-.4c-.2 0-.4-.2-.6-.2q-.3-.3 0-.6c.2-.4.4-.6.8-.6l36.3-.4c4.4-.2 8.9-3.7 10.6-7.9l2.1-5.4c0-.2.2-.4 0-.6C74.7 34.9 65.1 27 53.9 27c-10.4 0-19.3 6.6-22.4 16-2.1-1.5-4.6-2.3-7.5-2.1-5 .4-8.9 4.6-9.5 9.5-.2 1.2 0 2.5.2 3.7C6.6 54.4 0 61 0 69.3c0 .8 0 1.5.2 2.3 0 .4.4.6.6.6h66.6c.4 0 .8-.2.8-.6z"/><path fill="#B8B8B8" d="M80.3 46.1h-1c-.2 0-.4.2-.6.4l-1.5 5c-.6 2.1-.4 4.1.6 5.4 1 1.2 2.5 2.1 4.4 2.3l7.7.4c.2 0 .4.2.6.2q.3.3 0 .6c-.3.4-.5.6-.9.6l-7.9.4c-4.4.2-8.9 3.7-10.6 7.9l-.4 1.9c-.2.2 0 .6.4.6h27.4q.6 0 .6-.6c.4-1.7.8-3.5.8-5.4.1-10.8-8.8-19.7-19.6-19.7"/></g></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h100v100H0z"/></clipPath></defs></svg>} href="/integrations/cloudflare">
    Edge worker with zero latency impact
  </Card>

  <Card title="Vercel" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100" height="20" width="20"><path fill="#666" fillRule="evenodd" d="M100 93.957 50 7 0 93.957z" clipRule="evenodd"/></svg>} href="/integrations/vercel">
    No-code log drain integration
  </Card>

  <Card title="Azure CDN" icon={<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96" fill="#555" fillRule="evenodd" height="20" width="20"><defs><linearGradient id="azure-intro-grad1" x1="0" x2="0" y1="0" y2="1"><stop offset="0" stopColor="#888"/><stop offset="1" stopColor="#333"/></linearGradient><linearGradient id="azure-intro-grad2" x1="0" x2="0" y1="0" y2="1"><stop offset="0" stopOpacity=".3"/><stop offset="1" stopOpacity="0"/></linearGradient><linearGradient id="azure-intro-grad3" x1="0" x2="0" y1="0" y2="1"><stop offset="0" stopColor="#bbb"/><stop offset="1" stopColor="#666"/></linearGradient></defs><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#azure-intro-grad1)" d="M33.338 6.544h26.038l-27.03 80.087a4.152 4.152 0 0 1-3.933 2.824H8.149a4.145 4.145 0 0 1-3.928-5.47L29.404 9.368a4.152 4.152 0 0 1 3.934-2.825z"/><path fill="#555" d="M71.175 60.261h-41.29a1.911 1.911 0 0 0-1.305 3.309l26.532 24.764a4.171 4.171 0 0 0 2.846 1.121h23.38z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#azure-intro-grad2)" d="M33.338 6.544a4.118 4.118 0 0 0-3.943 2.879L4.252 83.917a4.14 4.14 0 0 0 3.908 5.538h20.787a4.443 4.443 0 0 0 3.41-2.9l5.014-14.777 17.91 16.705a4.237 4.237 0 0 0 2.666.972H81.24L71.024 60.261l-29.781.007L59.47 6.544z"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#azure-intro-grad3)" d="M66.595 9.364a4.145 4.145 0 0 0-3.928-2.82H33.648a4.146 4.146 0 0 1 3.928 2.82l25.184 74.62a4.146 4.146 0 0 1-3.928 5.472h29.02a4.146 4.146 0 0 0 3.927-5.472z"/></svg>} href="/integrations/azure-cdn">
    Azure Function for CDN & Front Door logs
  </Card>

  <Card title="AWS CloudFront" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100" height="20" width="20"><g clipPath="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#aws-a)"><path fill="#2e2e2e" d="M28.2 41.7c0 1.2.1 2.2.4 3 .3.7.6 1.5 1.1 2.4.2.3.2.5.2.8s-.2.7-.6 1l-2.1 1.4q-.45.3-.9.3c-.3 0-.7-.2-1-.5-.5-.5-.9-1-1.2-1.6s-.7-1.2-1-2c-2.6 3.1-5.9 4.6-9.8 4.6-2.8 0-5-.8-6.7-2.4C5 47.1 4.1 45 4.1 42.3q0-4.2 3-6.9c2-1.7 4.7-2.6 8.1-2.6 1.1 0 2.3.1 3.5.3s2.5.4 3.8.7v-2.4c0-2.5-.5-4.3-1.6-5.3q-1.65-1.5-5.4-1.5c-1.2 0-2.4.1-3.6.4s-2.4.7-3.6 1.1c-.5.2-.9.4-1.2.4-.2.1-.4.1-.5.1-.5 0-.7-.3-.7-1V24c0-.5.1-.9.2-1.2.2-.2.5-.5.9-.7q1.8-.9 4.2-1.5c1.6-.4 3.4-.6 5.2-.6q6 0 8.7 2.7c1.8 1.8 2.8 4.5 2.8 8.2zm-13.5 5.1c1.1 0 2.2-.2 3.4-.6s2.3-1.1 3.2-2.1c.5-.6.9-1.3 1.1-2.1s.3-1.8.3-2.9v-1.4c-1-.2-2-.4-3.1-.6-1.1-.1-2.1-.2-3.1-.2-2.2 0-3.9.4-5 1.3-1 .9-1.5 2.2-1.5 3.8s.4 2.7 1.2 3.5c.8.9 1.9 1.3 3.5 1.3m26.7 3.6c-.6 0-1-.1-1.3-.3s-.5-.7-.7-1.3L31.6 23c-.2-.7-.3-1.1-.3-1.3 0-.5.3-.8.8-.8h3.3c.6 0 1.1.1 1.3.3.3.2.5.7.7 1.3l5.6 22 5.2-22c.2-.7.4-1.1.6-1.3.3-.2.7-.3 1.3-.3h2.7c.6 0 1.1.1 1.3.3.3.2.5.7.6 1.3L60 44.8l5.8-22.3c.2-.7.4-1.1.7-1.3s.7-.3 1.3-.3h3.1c.5 0 .8.3.8.8 0 .2 0 .3-.1.5 0 .2-.1.5-.2.8l-8 25.7c-.2.7-.4 1.1-.7 1.3s-.7.3-1.3.3h-2.9c-.6 0-1.1-.1-1.3-.3-.3-.2-.5-.7-.6-1.3l-5.2-21.5-5.1 21.4c-.2.7-.4 1.1-.6 1.3-.3.2-.7.3-1.3.3h-3zm42.7.9c-1.7 0-3.5-.2-5.1-.6-1.7-.4-3-.8-3.8-1.3-.5-.3-.9-.6-1-.9s-.2-.6-.2-.9v-1.7c0-.7.3-1 .8-1 .2 0 .4 0 .6.1s.5.2.8.3c1.1.5 2.4.9 3.7 1.2s2.6.4 4 .4c2.1 0 3.7-.4 4.9-1.1s1.7-1.8 1.7-3.2c0-.9-.3-1.7-.9-2.3s-1.7-1.2-3.4-1.7l-4.8-1.5c-2.4-.8-4.2-1.9-5.3-3.4s-1.7-3.1-1.7-4.8c0-1.4.3-2.6.9-3.7q.9-1.65 2.4-2.7c1-.8 2.1-1.3 3.5-1.7q1.95-.6 4.2-.6c.7 0 1.5 0 2.2.1.8.1 1.5.2 2.2.4s1.3.3 1.9.5 1.1.4 1.4.6c.5.3.8.5 1 .8s.3.6.3 1.1v1.6c0 .7-.3 1.1-.8 1.1-.3 0-.7-.1-1.3-.4-1.9-.9-4-1.3-6.4-1.3-1.9 0-3.4.3-4.4.9s-1.6 1.6-1.6 3c0 .9.3 1.7 1 2.4.7.6 1.9 1.3 3.7 1.8l4.7 1.5c2.4.8 4.1 1.8 5.2 3.2 1 1.4 1.5 2.9 1.5 4.7q0 2.1-.9 3.9c-.6 1.1-1.4 2.1-2.4 2.9s-2.3 1.4-3.7 1.9c-1.6.1-3.2.4-4.9.4"/><path fill="#a7a7a7" fillRule="evenodd" d="M90.4 67.4c-10.9 8.1-26.8 12.4-40.5 12.4-19.2 0-36.4-7.1-49.5-18.9-1-.9-.1-2.2 1.1-1.5C15.6 67.6 33 72.5 51 72.5c12.1 0 25.5-2.5 37.7-7.7 1.9-.7 3.5 1.3 1.7 2.6" clipRule="evenodd"/><path fill="#a7a7a7" fillRule="evenodd" d="M95 62.2c-1.4-1.8-9.2-.9-12.8-.4-1.1.1-1.2-.8-.3-1.5 6.3-4.4 16.5-3.1 17.7-1.7 1.2 1.5-.3 11.8-6.2 16.7-.9.8-1.8.4-1.4-.6 1.4-3.3 4.4-10.7 3-12.5" clipRule="evenodd"/></g><defs><clipPath id="aws-a"><path fill="#fff" d="M0 0h100v100H0z"/></clipPath></defs></svg>} href="/integrations/cloudfront">
    S3 log processor for CloudFront access logs
  </Card>

  <Card title="WordPress" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100" height="20" width="20"><g fill="#666" clipPath="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#wp-a)"><path d="M7.1 50c0 17 9.9 31.7 24.2 38.6L10.8 32.5C8.4 38 7.1 44 7.1 50M79 47.8c0-5.3-1.9-9-3.5-11.8-2.2-3.5-4.2-6.5-4.2-10.1 0-3.9 3-7.6 7.2-7.6h.6C71.5 11.3 61.3 7 50.1 7c-15 0-28.2 7.7-35.8 19.3 1 0 2 .1 2.8.1 4.5 0 11.4-.5 11.4-.5 2.3-.1 2.6 3.3.3 3.5 0 0-2.3.3-4.9.4l15.6 46.5 9.4-28.2L42 29.9c-2.3-.1-4.5-.4-4.5-.4-2.3-.1-2-3.7.3-3.5 0 0 7.1.5 11.3.5 4.5 0 11.4-.5 11.4-.5 2.3-.1 2.6 3.3.3 3.5 0 0-2.3.3-4.9.4L71.4 76l4.3-14.3c1.8-5.9 3.3-10.2 3.3-13.9"/><path d="M50.8 53.8 37.9 91.1c3.9 1.2 8 1.7 12.1 1.7 5 0 9.8-.9 14.2-2.4l-.3-.6zm36.8-24.4c.2 1.4.3 2.8.3 4.4 0 4.4-.8 9.2-3.3 15.4l-13 37.9C84.3 79.6 92.9 65.8 92.9 50c0-7.2-1.8-14.3-5.3-20.6"/><path d="M50 0C22.4 0 0 22.4 0 50s22.4 50 50 50 50-22.4 50-50S77.6 0 50 0m0 97.7C23.7 97.7 2.3 76.3 2.3 50S23.7 2.3 50 2.3 97.7 23.7 97.7 50 76.3 97.7 50 97.7"/></g><defs><clipPath id="wp-a"><path fill="#fff" d="M0 0h100v100H0z"/></clipPath></defs></svg>} href="/integrations/wordpress">
    No-code plugin from the WP directory
  </Card>

  <Card title="Website Builders" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="#666" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" height="20" width="20"><circle cx="12" cy="12" r="10"/><path d="M2 12h20"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg>} href="/integrations/website-builders">
    Webflow, Framer, HubSpot & other hosted builders
  </Card>

  <Card title="Next.js" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100" height="20" width="20"><g clipPath="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#nextjs-a)"><path fill="#666" d="M50 100c27.6 0 50-22.4 50-50S77.6 0 50 0 0 22.4 0 50s22.4 50 50 50"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#nextjs-b)" d="M83.1 87.5 38.4 30H30v40h6.7V38.5l41 53c1.9-1.2 3.7-2.5 5.4-4"/><path fill="url(https://mintlify.s3.us-west-1.amazonaws.com/gptrends/#nextjs-c)" d="M70.6 30h-6.7v40h6.7z"/></g><defs><linearGradient id="nextjs-b" x1="51.794" x2="71.517" y1="71.791" y2="96.235" gradientUnits="userSpaceOnUse"><stop stopColor="#fff"/><stop offset="1" stopColor="#fff" stopOpacity="0"/></linearGradient><linearGradient id="nextjs-c" x1="67.299" x2="67.187" y1="29.987" y2="59.362" gradientUnits="userSpaceOnUse"><stop stopColor="#fff"/><stop offset="1" stopColor="#fff" stopOpacity="0"/></linearGradient><clipPath id="nextjs-a"><path fill="#fff" d="M0 0h100v100H0z"/></clipPath></defs></svg>} href="/integrations/nextjs">
    Lightweight middleware package
  </Card>

  <Card title="Fastly" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="#666" viewBox="0 0 24 24" height="20" width="20"><path d="M13.919 3.036V1.3h.632V0H9.377v1.3h.631v1.749a10.572 10.572 0 00-8.575 10.384C1.433 19.275 6.17 24 12 24c5.842 0 10.567-4.737 10.567-10.567 0-5.186-3.729-9.486-8.648-10.397zm-1.628 15.826v-.607h-.619v.607c-2.757-.158-4.955-2.38-5.101-5.137h.607v-.62h-.607a5.436 5.436 0 015.101-5.089v.607h.62v-.607a5.435 5.435 0 015.137 5.114h-.607v.619h.607a5.444 5.444 0 01-5.138 5.113zm2.26-7.712l-.39-.389-1.979 1.725a.912.912 0 00-.316-.06c-.534 0-.971.448-.971.995 0 .547.437.996.971.996.535 0 .972-.45.972-.996a.839.839 0 00-.049-.304Z"/></svg>}>
    Coming soon
  </Card>

  <Card title="HTTP API" icon={<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="#666" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" height="20" width="20"><rect x="2" y="2" width="20" height="8" rx="2" ry="2"/><rect x="2" y="14" width="20" height="8" rx="2" ry="2"/><line x1="6" y1="6" x2="6.01" y2="6"/><line x1="6" y1="18" x2="6.01" y2="18"/></svg>} href="/integrations/http-api">
    Send events from any backend
  </Card>
</CardGroup>

## Security & privacy

Our integrations are designed with security and privacy in mind:

* No personal identifying information (PII) is stored or logged
* All integrations run asynchronously and never interfere with page responses
* Errors are silently caught and discarded. Your site runs exactly as before

<Tip>
  **Need help getting set up?** [Book a call](https://cal.com/team/siteline/tech-set-up) and we'll walk you through it.
</Tip>


# Mentions Building
Source: https://docs.siteline.ai/mentions-building

Get your brand mentioned on real publications to drive AI agent citations and product mentions.

## Why Mentions Building matters

AI search engines like ChatGPT, Perplexity, Gemini, and Google AI Overviews generate answers by pulling from sources they consider authoritative. When your brand is mentioned on sites that AI agents frequently cite, you're more likely to appear in those answers.

According to [research by Ahrefs](https://ahrefs.com/blog/ai-overview-brand-correlation/), branded web mentions are the strongest correlated factor for appearing in AI-generated answers — ahead of domain rating, branded search volume, and number of referring domains.

Mentions Building helps you close the gap by getting your brand placed on the same types of publications your competitors are already mentioned on.

## How it works

1. **You submit an order** — choose the page you want to promote, a content type, and how many placements you'd like across different publisher quality tiers.

2. **We match you with publishers** — we find topically relevant publications in your category that meet the quality tier you selected (based on Domain Rating and organic traffic).

3. **Content is created and published** — a relevant article is written that naturally mentions your brand and links to your page. Content types include contextual mentions, listicles, product reviews, and comparison guides.

4. **You track the results** — once a placement goes live, you can monitor it in the Orders and Placements tabs. Over time, you can cross-reference placements with changes in your [AI Visibility](/metrics-glossary) metrics to measure impact.

## Placing an order

Navigate to **Mentions Building** → **New Order** in the left sidebar.

### Page to promote

Enter the URL of the page you want publishers to link to. This is typically your homepage, a key product page, or a landing page you want to drive authority to.

You can optionally specify a preferred anchor text — the clickable text used for the link. If you don't specify one, we'll choose something natural and contextually relevant.

### Content type request

Choose the type of article you'd like your brand placed in:

| Content Type             | Description                                                                        | Pricing                |
| ------------------------ | ---------------------------------------------------------------------------------- | ---------------------- |
| **Contextual placement** | A natural brand mention within a relevant article                                  | Included in base price |
| **Listicle**             | "Top X tools for Y" style article — a format frequently cited by AI search engines | +20%                   |
| **Product review**       | A dedicated review or feature walkthrough of your product                          | +20%                   |
| **Comparison guide**     | A side-by-side comparison with competitors                                         | +20%                   |

<Tip>
  Listicles and comparison guides tend to perform well for AI visibility because AI search engines frequently cite these formats when answering product discovery queries like "What are the best tools for X?"
</Tip>

### Content guidelines

You can provide optional guidance on what should be included in the content. This is not guaranteed but helps our publishers understand what angles matter to you.

**Examples:**

* "Write a listicle on the best analytics tools for the agentic web and include Siteline as one of the top options."
* "Focus on our real-time AI agent traffic monitoring capabilities."
* "Position us as the best option for companies concerned about AI crawler impact on their infrastructure."

### Publisher quality tiers

Each placement targets a publisher within a specific quality range, measured by [Ahrefs Domain Rating (DR)](https://ahrefs.com/blog/domain-rating/) and monthly organic traffic:

| Tier          | Domain Rating | Organic Traffic | Price per placement |
| ------------- | ------------- | --------------- | ------------------- |
| **Starter**   | 20+           | 100–5k          | \$100               |
| **Standard**  | 30+           | 100–10k         | \$160               |
| **Authority** | 40+           | 500–20k         | \$240               |
| **Power**     | 50+           | 1k–30k          | \$400               |
| **Elite**     | 60+           | 1k–100k         | \$500               |

You can customize the number of placements at each tier using the quantity controls in the **Customize your publisher mix** section.

### Volume discounts

Larger orders receive automatic discounts:

| Order total | Discount |
| ----------- | -------- |
| \$500+      | 5% off   |
| \$1,000+    | 10% off  |

The discount nudge below the order summary shows how close you are to the next discount tier.

### Add-ons

**Publisher domain approval** — by default, we handle publisher selection end-to-end (auto-approval). If you'd like to review and approve each publisher domain before content is placed, you can enable "Require approval + specifications" for an additional 20%.

**Express delivery** — standard turnaround is 28 days. If you need placements faster, express delivery (14 days) is available for an additional 20%.

## Submitting your order

Once your order is configured, review the **Order summary** sidebar on the right which shows your line items, any content type add-ons, discounts, and the total price.

Click **Submit Order** to place your request. We'll send you a confirmation email with payment instructions and order details.

## Tracking your orders

### Orders tab

The **Orders** tab shows all your submitted orders with their current status:

| Status          | Meaning                                                         |
| --------------- | --------------------------------------------------------------- |
| **In Progress** | Your order has been received and placements are being fulfilled |
| **Completed**   | All placements in the order have been published                 |
| **Cancelled**   | The order was cancelled                                         |

### Placements tab

The **Placements** tab shows individual placements that have gone live, including the publisher domain, article URL, and publication date. As placements are indexed, you can cross-reference this data with your AI Visibility tracking to measure impact over time.

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What kind of sites will my brand be placed on?">
    Real publications with genuine organic traffic, commercially valuable search rankings, and topical relevance to your category. We don't use spammy networks, private blog networks (PBNs), or low-quality content farms.
  </Accordion>

  <Accordion title="Are placements guaranteed?">
    We match you with publishers that meet the quality tier you selected. While we can't guarantee a specific domain, we guarantee that every placement will meet the minimum Domain Rating and traffic thresholds for your chosen tier.
  </Accordion>

  <Accordion title="Can I choose the exact site my brand is placed on?">
    Not directly — we handle publisher matching to ensure relevance and quality. If you enable Publisher domain approval (+20%), you can review and approve each domain before content is placed.
  </Accordion>

  <Accordion title="How long does it take?">
    Standard turnaround is approximately 28 days from order submission to published placement. Express delivery (14 days) is available as an add-on.
  </Accordion>

  <Accordion title="What's included in the price?">
    Each placement includes publisher outreach, content creation, and publishing. You control the target URL, preferred anchor text, and content guidelines.
  </Accordion>

  <Accordion title="How does this help with AI visibility?">
    AI search engines generate answers by referencing sources they consider authoritative. When your brand is mentioned on publications that AI agents cite, you're more likely to be included in AI-generated answers for relevant queries. You can track this impact directly in Siteline's [AI Visibility](/metrics-glossary) feature.
  </Accordion>

  <Accordion title="Can I order placements for multiple pages?">
    Currently, each order targets a single page URL. If you'd like placements pointing to different pages, submit separate orders.
  </Accordion>

  <Accordion title="Do you offer ongoing or recurring placements?">
    Not yet — Mentions Building is currently pay-per-order. We're exploring subscription options based on beta feedback.
  </Accordion>
</AccordionGroup>


# Metrics Glossary
Source: https://docs.siteline.ai/metrics-glossary

Definitions for the key visibility metrics used in the application

*Last updated February 7th, 2026*

## Overview

The Siteline platform provides precise data about your brand and product’s visibility across AI and traditional search platforms. Here you will find definitions of key terms with examples. Please feel free to reach out directly to the team at [<u>team@siteline.ai</u>](mailto:team@siteline.ai) if you need additional help.

## Tracking Metrics Definitions

<Card title="Visibility" icon="eye">
  **Definition:** The percentage of responses in which your (or a competitor’s) product appears. If the product is not present, the visibility is shown as “No”.

  *Example:* If your product appears in 6 of 10 responses from ChatGPT, then the visibility is 60%
</Card>

<Card title="Rank" icon="medal">
  **Definition:** Your product’s ranking by *visibility* compared to all products that appear in the prompt results.

  *Example:* If your competitor has a visibility of 28% and your product 25% for a given set of prompts or tag, then your rank is 2.
</Card>

<Card title="Position" icon="arrow-up-down">
  **Definition:** The position of your brand or product within response text. This is most often shown as an average across multiple responses.

  *Example:* In the sentence “Top project management tools include Asana, Trello, and Monday.com…”

  * Asana has a position of 1
  * Trello has a position of 2
  * Monday.com has a position of 3
</Card>

<Card title="Citations" icon="Award">
  **Definition:** When AI chatbots conduct a web search they provide citations in the form of links in addition to the text response. A citation is *associated* with a product means that the citation was placed near the product or brand name within the text. Often, but not always, this implies that the product or brand is mentioned in the text of cited page.

  <Note>
    Note: With the exception of Perplexity, AI chat apps do not always conduct a web search when providing an answer. This determination is made automatically based on whether the prompt requires niche or recent information.
  </Note>
</Card>

## Prompt Tracking Configuration Definitions

<Card title="Schedule">
  **Definition:** Schedule determines the frequency at which your prompts will run: daily, biweekly (2x per week), weekly, or bimonthly (2x per month). The schedule be adjusted by clicking ‘Edit Tracking’ from the Track section.
</Card>

<Card title="Run">
  **Definition**: One execution of all active prompts against the configured platforms. A run main contain multiple repetitions
</Card>

<Card title="Repetitions">
  **Definition:** The number of times each prompt executes per scheduled run. Repetitions can be adjusted by clicking ‘Edit Tracking’ from the Track section.

  <Note>
    *Note:* Unlike traditional SEO, LLM responses can different output for the same input. As such we recommend configuring multiple repetitions to collect robust data.
  </Note>
</Card>


# Prompt Generation Best Practices
Source: https://docs.siteline.ai/prompt-generation-best-practices

Tips for how to select representative custom prompts to use for visibility tracking.

## Getting Started

In addition to pre-generated and expanded prompts based on your competitors, Siteline allows you to enter a list of custom prompts during the tracking configuration process.

You can set up tracking for the first time or edit existing tracking by clicking the “Start Tracking” or "Edit Prompts" buttons in the Track section.

<Steps>
  <Step title="Start prompt tracking">
    <img alt="Enter Prompt Tracking" />
  </Step>

  <Step title="Prompt selection step">
    <img alt="Select Prompts" />

    * You can then add custom prompts one by one or paste in a comma-separated list
    * Once added an "estimated volume" field will be shown as a proxy for the amount of AI search conversation based on traditional search and other factors
  </Step>
</Steps>

## Keywords vs. Prompts

When selecting prompts the overall goal should be to pick a well distributed set that covers your key customer and product segments.

* Compared to keyword searches in Google, which consist of 2-5 words, prompts entered into ChatGPT tend to be longer and more customized to specific needs and uses e.g. “top CRMs” vs. “What are the top CRMs for small businesses with a rich integrations capabilities, particularly with Twilio.”
* Additionally, two prompts may have different text, but very similar semantic meaning and will likely lead to the same output e.g. “Best CRM for SMBs with Twilio integration.”

<Note>
  Given the above dynamics, we recommend crafting custom prompts that **cover your key segments** and **are semantically different** to ensure that your visibility results are **representative of your target audience** and **unbiased**
</Note>

## Suggested Prompt Selection Approach

### Step 1: Identify key segments

Note down some key segments or categories you use when thinking about targeting and analyzing your marketing efforts. Here are some common ones:

* Product category / features
* Ideal customer profile (ICP)
* Customer vertical
* Customer stage
* Purchaser role function
* Pain-point solved

### Step 2: Create tags within segments

For each of the categories above list out the segments, these can be used as Tags once within Siteline. Continuing with a CRM offering example:

* Product features:
  * Activity Tracking
  * Reporting
  * Integrations
* Customer Vertical
  * B2B SaaS
  * Marketing Agencies

### Step 3: Generate prompts by segment and segment cross-section

Generate a 4-8 word phrase or question with ***high product discovery*** intent for a single segment or a cross section of segments.

<Tip>
  **What do you mean by high product discovery intent?** The prompt should lead the AI Search platform to respond with specific product or brands names, not with only a definition or informational response.

  ❌ ”CRM integration capabilities”

  ✅ ”Top CRMs with integration capabilities”
</Tip>

### For a single segment

Sticking with the segment examples above, construct your prompts with the following structure:

> **"Best" / "Top" / "Recommend" + \[Your product category] + \[Segment]**

For example:

| Segment Category  | Segment (Tags)     | Example Prompt                                   |
| :---------------- | :----------------- | :----------------------------------------------- |
| Product features  | Activity Tracking  | Top CRMs with *activity tracking*                |
| Product features  | Reporting          | Top CRMs with *robust reporting*                 |
| Product features  | Integrations       | Top CRMs with *large integration* library        |
| Customer Vertical | B2B SaaS           | What are the best CRMs for *B2B Saas*?           |
| Customer Vertical | Marketing Agencies | What are the best CRMs for *marketing agencies*? |

### For segment cross-sections

After you have prompts that are one-to-one with segments you can create prompts that represent the cross-section of multiple segments. Note: Use as needed, not all cross-sections may make sense.

|                        | Activity tracking                                                 | Reporting                                                 | Integrations                                                       |
| :--------------------- | :---------------------------------------------------------------- | :-------------------------------------------------------- | :----------------------------------------------------------------- |
| **B2B SaaS**           | Top CRMs for *B2B SaaS* with strong *activity tracking*           | Top CRMs for *B2B SaaS* with *robust reporting*           | Top CRMs for *B2B SaaS* with a *large integration library*         |
| **Marketing Agencies** | Top CRMs for *marketing agencies* with strong *activity tracking* | Top CRMs for *marketing agencies* with *robust reporting* | Top CRMs for *marketing agencies* with *large integration library* |

### Step 4: Compile, comma-separate and paste into Siteline

Once your prompts are generated you can paste them into comma separated list of prompts in to the configuration step

## Prompt Weighting

When you enter prompts on Siteline the platform will automatically pull in a volume estimate based on the equivalent keywords on traditional search engines Google + Bing. To further weight your prompts for offline analysis we recommend using the following as proxies:

* Visitor traffic from to your website or blog
  * More traffic on a topic —> more interest —> higher weight
* Support tickets or demo requests by topic
* Hashtags or terms on social media
* Volume of **AI search requests from crawler or user bots** to various content pages of your website
  * For example, if you see lots of bots crawling your page about "Integrations", it's a good indication that there is user interest in that aspect of your poduct and related prompts should be strongly weighted.
  * Gain access to bot activity data directly in Siteline for free by setting up [Agent Analytics](/introduction).


# MCP server
Source: https://docs.siteline.ai/reporting/mcp

Connect your AI tools to Siteline using MCP

The Model Context Protocol (MCP) is a standard for connecting Large Language Models (LLMs) to platforms like Siteline. Once connected, your AI assistants can query Siteline Agent Analytics and AI Visibility data on your behalf.

## MCP Setup

Choose your MCP client and add Siteline using the instructions below.

<Tabs>
  <Tab title="Claude">
    In Claude or Claude Desktop, open **Settings** > **Connectors**, then add a custom connector:

    ```text theme={null}
    Name: Siteline
    URL: https://mcp.siteline.ai/mcp
    ```

    After saving the connector, use Claude's connector authentication flow to log in to Siteline
    and approve read-only analytics access for your team.
  </Tab>

  <Tab title="Claude Code">
    Add the MCP server with:

    ```bash theme={null}
    claude mcp add --transport http siteline https://mcp.siteline.ai/mcp
    ```

    Then authenticate from Claude Code:

    ```text theme={null}
    /mcp
    ```
  </Tab>

  <Tab title="Codex">
    Add the MCP server with:

    ```bash theme={null}
    codex mcp add siteline --url https://mcp.siteline.ai/mcp
    ```
  </Tab>

  <Tab title="Cursor">
    In Cursor, add Siteline as a remote MCP server from **Settings** > **Tools & Integrations** >
    **MCP**, or add this project configuration to `.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "siteline": {
          "url": "https://mcp.siteline.ai/mcp"
        }
      }
    }
    ```

    Cursor will open the OAuth flow when it first connects or when you run a Siteline tool.
  </Tab>

  <Tab title="JSON">
    Alternatively, add this configuration to `.mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "siteline": {
          "type": "http",
          "url": "https://mcp.siteline.ai/mcp"
        }
      }
    }
    ```
  </Tab>
</Tabs>

After configuring the MCP server, authenticate using your MCP client's authentication flow.

### Authentication

Some MCP clients automatically prompt you to log in during setup, while others require manual authentication steps. Authentication opens a browser window where you log in to Siteline and grant read-only analytics access for the selected team.

<Info>
  **Siteline MCP does not require you to generate or paste a public API key into the MCP client.**
</Info>

### Next steps

After you log in, check that the MCP server is connected. Depending on the client, you may need to restart it to connect and detect all tools after authorization.

To verify the client has access to the MCP server tools, ask it to query Siteline using natural language. For example: "Summarize prompt performance for my product using Siteline MCP."

## What you can ask

Once connected, ask your AI tool in plain language. It picks the right tools and handles the details. Try prompts like these:

<AccordionGroup>
  <Accordion title="Agent Analytics" icon="chart-no-axes-combined">
    * How has OpenAI bot traffic to my site changed over the last 3 months?
    * Compare AI-referred human visits week over week.
    * Which pages do AI crawlers hit most often?
  </Accordion>

  <Accordion title="AI Visibility" icon="eye">
    * Summarize my prompt performance on ChatGPT over the last 30 days.
    * Which tracked prompts am I ranking worst on, and which competitors are beating me?
    * Show how my Gemini visibility trended last month.
  </Accordion>

  <Accordion title="Citations" icon="medal">
    * What are the top pages citing my product in the last 30 days?
    * Which source domains mention my competitors but not me?
    * List the products most often mentioned alongside mine.
  </Accordion>
</AccordionGroup>

## Available tools

The server exposes seven read-only tools. Your AI tool selects these automatically, you don't need to call them by name. Each maps directly to an endpoint in the [Reporting API](/reporting/reporting-api-introduction), where you can find exact parameters and response fields.

| Tool                                   | Use it to                                                                                          |
| -------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `list_products`                        | List authorized primary products, product IDs, and domains for the MCP connection.                 |
| `list_product_websites`                | List active website domains and website IDs for a product.                                         |
| `list_product_tracked_prompts`         | List tracked prompt rows with platform, domain, position, visibility, rank, run count, and labels. |
| `summarize_product_prompt_performance` | Summarize aggregate prompt visibility, position, rank, and competitor count.                       |
| `analyze_product_prompt_trends`        | Analyze daily prompt visibility, position, and rank trends.                                        |
| `list_product_citations`               | List citation source pages, source domains, or mentioned products.                                 |
| `analyze_product_analytics_timeseries` | Analyze AI crawler and referred human traffic timeseries.                                          |

## Security risks

Connecting any data source to an LLM carries inherent risks. Siteline MCP is read-only, but AI tools can still retrieve and summarize analytics data that your team has access to.

<Warning>
  Prompt injection can trick an AI assistant into treating untrusted content as instructions. Review
  MCP tool calls before allowing them, especially in clients that can run tools automatically.
</Warning>

### Recommendations

* Review tool calls before approving them
* Connect only MCP clients you trust
* Use a Siteline team with the minimum data access needed
* Remove the MCP server from clients that no longer need access
* Revoke or reconnect the MCP client if you suspect a client token was exposed


# Reporting API
Source: https://docs.siteline.ai/reporting/reporting-api-introduction

Query Siteline product analytics from production systems over HTTP

The Siteline Reporting API gives production systems read-only access to product analytics, prompt performance, citations, and agent analytics traffic. Use it when you need to power internal dashboards, data pipelines, customer reporting, or agent workflows directly from Siteline data.

<Info>
  This page documents the Reporting API for reading analytics data. If you want to send pageview
  tracking events to Siteline, use the [Direct HTTP API](/integrations/http-api) instead.
</Info>

## Base URL

```text theme={null}
https://api.siteline.ai
```

All production requests must use HTTPS and return JSON.

## Authentication

Create a public API key in your Siteline workspace under **Team settings** > **Public API Key**. Only team admins can view, create, copy, or regenerate the key.

Pass the key as a bearer token:

```http theme={null}
Authorization: Bearer <public-api-key>
```

Example:

```bash theme={null}
curl \
  -H "Authorization: Bearer $SITELINE_PUBLIC_API_KEY" \
  "https://api.siteline.ai/v1/products"
```

<Warning>
  Treat the public API key as a production secret. Store it in a secret manager, never ship it to a
  browser or mobile client, and rotate it if it is exposed.
</Warning>

## Authorization model

The API key scopes every request to the Siteline team that owns the key and its managed teams.

* `GET /v1/products` returns primary products owned by that team or its managed teams
* Product-specific routes only return data for products owned by that team or its managed teams
* Competitor products linked through comparison data are not authorized as primary products
* Missing keys, invalid keys, revoked keys, malformed product IDs, and unauthorized products all return the same `401` response

```json theme={null}
{ "message": "Unauthorized." }
```

## Production client checklist

* Keep requests server-side; never expose the API key to end users
* Cache low-churn discovery calls like `GET /v1/products`
* Use RFC3339 timestamps for all date ranges, for example `2026-05-01T00:00:00Z`
* Keep date windows bounded to the reporting period your workflow needs
* Retry transient `5xx` failures with exponential backoff and jitter
* Do not retry `400` or `401` responses until inputs or credentials are fixed
* Log request path, status code, and a correlation ID, but never log the full API key
* Prefer `labelIds[]`, `platforms[]`, and `groupBy` filters over downloading broad datasets and filtering later

## Query conventions

Repeated filters use bracket notation:

```text theme={null}
platforms[]=openai&platforms[]=gemini&labelIds[]=7&labelIds[]=12
```

Prompt and citation endpoints share these query parameters:

| Name          | Required | Type              | Description                                                                                                              |
| ------------- | -------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `domain`      | Yes      | string            | Product domain to report metrics for, such as `example.com`.                                                             |
| `dateFrom`    | Yes      | RFC3339 timestamp | Inclusive start timestamp.                                                                                               |
| `dateTo`      | Yes      | RFC3339 timestamp | Inclusive end timestamp.                                                                                                 |
| `platforms[]` | No       | repeated string   | Platform filters. Common values include `openai`, `gemini`, `google`, `perplexity`, `google_ai_overviews`, and `claude`. |
| `labelIds[]`  | No       | repeated integer  | Prompt label IDs to filter on. Invalid IDs return `400`.                                                                 |

Invalid or missing query parameters return:

```json theme={null}
{ "message": "Invalid request parameters." }
```

## Error behavior

| Status | Response                                       | Meaning                                                |
| ------ | ---------------------------------------------- | ------------------------------------------------------ |
| `200`  | Endpoint response body                         | Request succeeded.                                     |
| `400`  | `{ "message": "Invalid request parameters." }` | Required query parameters are missing or malformed.    |
| `401`  | `{ "message": "Unauthorized." }`               | API key validation or product authorization failed.    |
| `500`  | `{ "message": "Internal server error." }`      | Unexpected server-side or upstream dependency failure. |

## Recommended sync pattern

For production ingestion jobs:

1. Call `GET /v1/products` and cache product IDs.
2. Call `GET /v1/products/{productId}/websites` and cache authorized domains.
3. Use `websiteId` on analytics timeseries requests when you need one website instead of all product websites combined.
4. Run narrow date-window requests for each product and domain.
5. Store the exact `dateFrom`, `dateTo`, endpoint path, and filters used for every sync batch.
6. On retries, re-run the same idempotent `GET` request with the same filters.

<Tip>
  Use the MCP server when an AI assistant should ask follow-up questions and choose tools
  interactively. Use the Reporting API when your own backend or data pipeline needs direct,
  repeatable access to Siteline analytics.
</Tip>


# Teams & Roles
Source: https://docs.siteline.ai/teams-and-roles

Manage team members and linked teams

## Overview

Every Siteline user belongs to a team. Within a team, users are assigned a **role** that determines what they can access and manage

You can invite new users and manage your team from **Settings → Team**.

## Roles

| Capability                                     | Admin | Member |
| :--------------------------------------------- | :---: | :----: |
| View products, tracking data & recommendations |   ✅   |    ✅   |
| Start or edit prompt tracking                  |   ✅   |    ✅   |
| Add or remove products & websites              |   ✅   |    ✅   |
| Invite or remove team members                  |   ✅   |    ❌   |
| Change member roles                            |   ✅   |    ❌   |
| Manage subscription & billing                  |   ✅   |    ❌   |
| Create or manage linked teams                  |   ✅   |    ❌   |

## Inviting Team Members

<Steps>
  <Step title="Open Team settings">
    Navigate to **Settings → Team → Members** and click **Invite member**.
  </Step>

  <Step title="Enter email addresses">
    Add one or more email addresses and select a role (Admin or Member) for each.
  </Step>

  <Step title="Send invitations">
    Invited users will receive an email with a link to create an account as a part of your team. Pending invitations can be resent or cancelled from the Members table.
  </Step>
</Steps>

<Note>
  **Note** At the moment only users without existing Siteline accounts can be invited to join a team through the invitation flow. If you'd like to add an existing Siteline user to your team please email [team@siteline.ai](mailto:team@siteline.ai)
</Note>

## Linked Teams

Linked teams let you create and manage separate teams under your account. Each linked team has its own members and can view its own products, websites, tracking data, and analytics, while your team owns the products, websites, tracking configuration, and billing on their behalf.
This is useful for agencies or consultants managing tracking for multiple clients.

### Setting Up a Linked Team

<Steps>
  <Step title="Open Linked Teams">
    Navigate to **Settings → Team → Linked Teams** and click **Add linked team**.
  </Step>

  <Step title="Invite the client team's admin">
    Enter the admin email for the team you want to link. They will receive an invitation to create an account.
  </Step>

  <Step title="Client accepts the invitation">
    Once accepted, the client team appears in your Linked Teams table with an **Active** status.
  </Step>
</Steps>

**Notes**

* Only users without existing Siteline accounts can be invited to manage a linked team through the invitation flow. If you'd like to link an existing user or team please contact [team@siteline.ai](mailto:team@siteline.ai)
* If the link from your team is removed, then the admin of the linked team will be able to fully manage billing and other settings.

### What Linked Team Users Can Do

| Capability                                               | Linked team admin | Linked team member |
| :------------------------------------------------------- | :---------------: | :----------------: |
| View products, websites, tracking data & recommendations |         ✅         |          ✅         |
| Add or remove products & websites                        |         ❌         |          ❌         |
| Start, edit, pause or resume prompt tracking             |         ❌         |          ❌         |
| Invite or remove their own team members                  |         ✅         |          ❌         |
| Manage subscription & billing                            |         ❌         |          ❌         |
| Create their own linked teams                            |         ❌         |          ❌         |

<Note>
  Billing and subscription settings for linked teams are controlled by the parent team. Linked team users will see a message directing them to contact the parent team for plan changes.
</Note>