# Fetch Config
Source: https://docs.ad-unblock.com/api-reference/fetch-config

Fetch AdUnblock latest configuration

# Configuration API Reference

The AdUnblock Configuration API provides access to the latest JavaScript configuration files needed for ad blocker detection on your website.

## Base URL

```
https://public.adunblocker.com
```

## Authentication

This API endpoint is publicly accessible and does not require authentication.

## Caching

The API responses are cached for optimal performance and support standard HTTP caching headers for efficient client-side caching.

## Server Tag Configuration

### Get JavaScript Configuration

Retrieve the latest JavaScript files needed for ad blocker detection.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://public.adunblocker.com/api/vendor_scripts
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch("https://public.adunblocker.com/api/vendor_scripts");
  const scripts = await response.json();
  ```

  ```python Python theme={null}
  import requests

  response = requests.get('https://public.adunblocker.com/api/vendor_scripts')
  scripts = response.json()
  ```
</CodeGroup>

#### Response

```json theme={null}
["https://cdn.example.com/detection-script.js"]
```

#### Response Format

The response is a JSON array containing JavaScript file URLs for ad blocker detection as strings.

#### Response Headers

| Header          | Description                                       |
| --------------- | ------------------------------------------------- |
| `Content-Type`  | `application/json`                                |
| `ETag`          | Entity tag for caching validation                 |
| `Last-Modified` | Timestamp when the configuration was last updated |

#### Usage Example

Once you fetch the configuration, you can dynamically load the JavaScript files:

```javascript theme={null}
// Fetch configuration
const scripts = await fetch(
  "https://public.adunblocker.com/api/vendor_scripts"
).then((response) => response.json());

// Load the JavaScript files
scripts.forEach((scriptUrl) => {
  const script = document.createElement("script");
  script.src = scriptUrl;
  script.async = true;
  document.head.appendChild(script);
});
```

#### Caching Recommendations

* The API supports standard HTTP caching headers
* Implement conditional requests using `If-None-Match` header with ETag
* Cache responses locally for better performance
* Check for updates periodically (e.g., every hour)

```javascript theme={null}
// Example with conditional request
const etag = localStorage.getItem("config-etag");
const headers = etag ? { "If-None-Match": etag } : {};

const response = await fetch("https://public.adunblocker.com/api/vendor_scripts", {
  headers,
});

if (response.status === 304) {
  // Use cached configuration
  console.log("Configuration unchanged");
} else {
  // Update cache
  const scripts = await response.json();
  localStorage.setItem("config-etag", response.headers.get("ETag"));
  localStorage.setItem("config-data", JSON.stringify(scripts));
}
```

## Valid Script Sources (Deprecated)

<Warning>
  This endpoint is deprecated and will be removed in a future version. Please
  use the `/api/vendor_scripts` endpoint instead.
</Warning>

### Get Valid Script Sources

Retrieve a list of valid JavaScript source URLs for ad blocker detection.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://config.adunblocker.com/valid_script_sources.json
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    "https://config.adunblocker.com/valid_script_sources.json"
  );
  const sources = await response.json();
  ```

  ```python Python theme={null}
  import requests

  response = requests.get('https://config.adunblocker.com/valid_script_sources.json')
  sources = response.json()
  ```
</CodeGroup>

#### Response

```json theme={null}
["https://cdn.example.com/detection-script.js"]
```

#### Response Format

The response is a JSON array containing valid JavaScript source URLs as strings.

#### Response Headers

| Header          | Description                                       |
| --------------- | ------------------------------------------------- |
| `Content-Type`  | `application/json`                                |
| `ETag`          | Entity tag for caching validation                 |
| `Last-Modified` | Timestamp when the configuration was last updated |

#### Migration Guide

If you're currently using this endpoint, migrate to the new `/api/vendor_scripts` endpoint:

```javascript theme={null}
// Old (deprecated)
const sources = await fetch(
  "https://config.adunblocker.com/valid_script_sources.json"
).then((response) => response.json());

// New (recommended)
const scripts = await fetch(
  "https://public.adunblocker.com/api/vendor_scripts"
).then((response) => response.json());
// scripts is already an array, no need to access .js property
```


# Getting Started
Source: https://docs.ad-unblock.com/get-started

Start recovering your lost ad revenue in a few simple steps

# Getting Started with Ad Unblock

Start recovering your lost ad revenue in a few simple steps

## Dashboard-Guided Integration

The Ad Unblock dashboard provides personalized, step-by-step instructions for your specific setup.

## Quick Start Guide

<Steps>
  <Step title="Create Your Account">
    Sign up for an Ad Unblock account to access the dashboard and all features.

    [Register Now](https://ad-unblock.com/signup)
  </Step>

  <Step title="Add Your Website">
    Once logged in, add your website to the dashboard to receive a unique verification code.

    **Dashboard → Add Site**
  </Step>

  <Step title="Follow Dashboard Instructions">
    The dashboard provides customized integration steps for your specific platform. Simply follow these instructions to integrate Ad Unblock.

    * Platform-specific guides
    * Custom verification code
    * One-click verification
  </Step>
</Steps>

### Ready to get started?

Sign up for a free trial and start recovering your ad revenue today.

<CardGroup>
  <Card title="Start Free Trial" icon="rocket" href="https://ad-unblock.com/signup">
    Get started with your free trial today
  </Card>

  <Card title="Contact Us" icon="headset" href="https://ad-unblock.com/contact">
    Get personalized help from our team
  </Card>
</CardGroup>


# Express
Source: https://docs.ad-unblock.com/guides/express

Express middleware for script loading and injection with TypeScript support

A powerful Express middleware for server-side script loading and injection. Load external scripts from remote JSON endpoints with caching, security, and flexible integration options. Built with TypeScript for full type safety.

## Installation

```bash theme={null}
npm install @adunblock/server-tag-express
```

<Warning>
  Every rendered `<script>` tag **must** include a `data-code` attribute set
  to your Account ID (verification code). AdUnblock uses this value to verify
  that the script is running on your registered domain. Find your Account ID
  at the top of your AdUnblock dashboard.
</Warning>

## Quick Start

```typescript theme={null}
import express from "express";
import { serverTagMiddleware } from "@adunblock/server-tag-express";

const app = express();

// Add ServerTag middleware with TypeScript support
app.use(
  serverTagMiddleware({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
    scriptAttributes: {
      "data-code": "YOUR_ACCOUNT_ID", // Required: your Account ID
    },
  })
);

// Your routes will now have access to script data
app.get("/", (req, res) => {
  // Scripts available in res.locals.serverTagScripts (fully typed!)
  res.send(`
    <html>
      <head>
        ${res.locals.serverTagHtml}
      </head>
      <body>
        <h1>Hello World!</h1>
      </body>
    </html>
  `);
});

app.listen(3000);
```

## TypeScript Support

This package is written in TypeScript and provides comprehensive type definitions:

```typescript theme={null}
import type {
  ServerTagMiddlewareOptions,
  ScriptAttributes,
  ServerTagConfig,
} from "@adunblock/server-tag-express";

const config: ServerTagMiddlewareOptions = {
  remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
  cacheInterval: 300,
  scriptAttributes: {
    "data-code": "YOUR_ACCOUNT_ID", // Required: your Account ID (verification code)
    async: true,
    defer: false,
  },
};

app.use(serverTagMiddleware(config));
```

## Expected Remote Response Format

Your remote URL should return JSON in this format:

```json theme={null}
["https://example.com/script1.js", "https://example.com/script2.js"]
```

## Integration Methods

### 1. Template Integration (Recommended)

Use with any template engine (EJS, Handlebars, Pug, etc.):

#### EJS Example

```html theme={null}
<head>
  <title>My App</title>
  <%- serverTagHtml %>
</head>
```

#### Handlebars Example

```html theme={null}
<head>
  <title>My App</title>
  {{{serverTagHtml}}}
</head>
```

#### Pug Example

```pug theme={null}
head
  title My App
  != serverTagHtml
```

### 2. Auto Injection

Automatically inject scripts into HTML responses:

```typescript theme={null}
app.use(
  serverTagMiddleware({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
    injectIntoHtml: true,
    injectPosition: "</head>", // Where to inject
    scriptAttributes: { async: true }, // Script tag attributes
  })
);
```

### 3. Manual Injection

Programmatically inject scripts into HTML strings:

```typescript theme={null}
import { injectScripts } from "@adunblock/server-tag-express";

app.get("/page", (req, res) => {
  let html = "<html><head></head><body>Content</body></html>";

  // Inject scripts manually (fully typed)
  html = injectScripts(html, res.locals.serverTagScripts || []);

  res.send(html);
});
```

### 4. Direct Access

Access script data directly for custom implementations:

```typescript theme={null}
app.get("/custom", (req, res) => {
  const scripts: string[] = res.locals.serverTagScripts || [];

  // Custom script rendering with type safety
  const scriptTags = scripts
    .map((url) => `<script src="${url}" async></script>`)
    .join("\n");

  res.send(`<html><head>${scriptTags}</head>...</html>`);
});
```

## Configuration Options

| Option             | Type               | Default         | Description                             |
| ------------------ | ------------------ | --------------- | --------------------------------------- |
| `remoteUrl`        | `string`           | **Required**    | URL to fetch script configuration from  |
| `cacheInterval`    | `number`           | `300`           | Cache duration in seconds               |
| `injectIntoHtml`   | `boolean`          | `true`          | Auto-inject scripts into HTML responses |
| `injectPosition`   | `string`           | `'</head>'`     | Where to inject scripts in HTML         |
| `scriptAttributes` | `ScriptAttributes` | `{async: true}` | Additional attributes for script tags   |
| `onError`          | `function`         | `undefined`     | Custom error handler function           |
| `shouldInject`     | `function`         | `() => true`    | Conditional injection logic             |

## Advanced Configuration

```typescript theme={null}
import type { ServerTagMiddlewareOptions } from "@adunblock/server-tag-express";

const config: ServerTagMiddlewareOptions = {
  remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
  cacheInterval: 600, // 10 minutes
  injectIntoHtml: true,
  injectPosition: "</head>",
  scriptAttributes: {
    defer: true,
    "data-source": "server-tag",
  },
  shouldInject: (req, res) => {
    // Don't inject scripts on API routes
    return !req.path.startsWith("/api/");
  },
  onError: (error, req, res) => {
    console.error("ServerTag error:", error.message);
    // Optional: send error to monitoring service
  },
};

app.use(serverTagMiddleware(config));
```

## Route-Specific Configuration

Apply ServerTag to specific routes with different configurations:

```typescript theme={null}
// Global middleware
app.use(
  serverTagMiddleware({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
  })
);

// Route-specific middleware
app.get(
  "/special",
  serverTagMiddleware({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
    cacheInterval: 60, // 1 minute cache
    scriptAttributes: { defer: true },
  }),
  (req, res) => {
    res.render("special-page");
  }
);
```

## API Reference

### `serverTagMiddleware(options)`

Main middleware function that adds ServerTag functionality to Express apps.

**Parameters:**

* `options` (ServerTagMiddlewareOptions): Configuration options

**Returns:** Express middleware function

### `injectScripts(html, scripts, attributes, position)`

Helper function to manually inject scripts into HTML strings.

**Parameters:**

* `html` (string): HTML string to modify
* `scripts` (string\[]): Array of script URLs
* `attributes` (ScriptAttributes): Script tag attributes
* `position` (string): Where to inject (default: `'</head>'`)

**Returns:** Modified HTML string

### Type Definitions

```typescript theme={null}
interface ServerTagConfig {
  cacheInterval?: number;
  timeout?: number;
  retries?: number;
  retryDelay?: number;
}

interface ScriptAttributes {
  async?: boolean;
  defer?: boolean;
  type?: string;
  [key: string]: string | boolean | number | undefined;
}

interface ServerTagMiddlewareOptions extends ServerTagConfig {
  remoteUrl: string;
  injectIntoHtml?: boolean;
  injectPosition?: string;
  scriptAttributes?: ScriptAttributes;
  onError?: (error: Error, req: Request, res: Response) => void;
  shouldInject?: (req: Request, res: Response) => boolean;
}
```

## Error Handling

ServerTag includes robust error handling with custom error types:

```typescript theme={null}
import {
  ServerTagError,
  NetworkError,
  ValidationError,
  TimeoutError,
} from "@adunblock/server-tag-express";

app.use(
  serverTagMiddleware({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
    onError: (error, req, res) => {
      if (error instanceof NetworkError) {
        console.error("Network error:", error.message);
      } else if (error instanceof ValidationError) {
        console.error("Validation error:", error.message);
      } else if (error instanceof TimeoutError) {
        console.error("Timeout error:", error.message);
      }

      // Scripts will be empty array on error
      console.log("Scripts loaded:", res.locals.serverTagScripts?.length || 0);
    },
  })
);
```

## Browser Compatibility

ServerTag works with all browsers supported by the generated script tags. The middleware itself runs on Node.js 16+.


# Others (HTML/JS)
Source: https://docs.ad-unblock.com/guides/html-javascript

Direct integration using vanilla HTML and JavaScript

<Info>
  **Where to find your verification code**: Your verification code is your
  **Account ID**, shown at the top of your AdUnblock dashboard.
</Info>

<Warning>
  The `data-code` attribute is **required**. Set it to your Account ID
  (verification code) — AdUnblock uses this value to verify that the script is
  running on your registered domain.
</Warning>

<Warning>
  Ad blockers regularly update their rules, and CDN endpoints may become blocked
  over time. As a site owner, you are responsible for using the latest valid CDN
  endpoints by regularly checking the System Status page or implementing
  server-side fetching from `https://public.adunblocker.com/api/vendor_scripts`.
</Warning>

<Steps>
  <Step title="Add the Script">
    Add the following script to your website's `<head>` section:

    ```html theme={null}
    <script src="LATEST_SCRIPT_URL" async data-code="YOUR_VERIFICATION_CODE"></script>
    ```

    **Important:**

    * Replace `YOUR_VERIFICATION_CODE` with your unique verification code from the dashboard.
    * Replace `LATEST_SCRIPT_URL` with the current script URL. Fetch the latest script URL from: `https://public.adunblocker.com/api/vendor_scripts`
  </Step>

  <Step title="Server-side Integration (Recommended)">
    For production environments, implement server-side fetching from our API with proper caching.
  </Step>

  <Step title="Verify Integration">
    After adding the script, verify your integration is working properly by navigating to your site and checking if the ads are visible.
  </Step>
</Steps>

## Verification Code

Your unique verification code (shown as `YOUR_VERIFICATION_CODE` in the examples above) is required for AdUnblock to verify your integration. This code is specific to your registered domain.

## Available Script Sources

We provide multiple CDN endpoints to enhance reliability. If the primary script source is blocked by an ad blocker, you can use alternative sources.

<Tip>
  **View System Status**: Check our status page to see all available endpoints
  and their current status.
</Tip>

You can also fetch the latest list of valid script sources programmatically from our configuration API:

```
https://public.adunblocker.com/api/vendor_scripts
```

### Important Notice

As a site owner, you are responsible for ensuring your integration uses the latest valid CDN endpoints. Ad blockers regularly update their rules, which may block our endpoints. We recommend:

* Regularly check the System Status page for updated endpoint information
* For production environments, implement server-side fetching from our API with proper caching
* Use the API endpoint `https://public.adunblocker.com/api/vendor_scripts` to programmatically retrieve the latest valid scripts
* Never implement client-side fallbacks that fetch from our API directly

## Need help with implementation?

Our support team is ready to assist you with any questions or issues.

<Card title="Contact Support" icon="headset" href="https://ad-unblock.com/contact">
  Get personalized help from our technical support team.
</Card>


# Next.js
Source: https://docs.ad-unblock.com/guides/nextjs

Script loading for Next.js applications with React Server Components

A Next.js React Server Component for fetching and rendering external JavaScript files on the server-side before page rendering. This package provides secure, cached script loading with TypeScript support.

## Installation

```bash theme={null}
npm install @adunblock/server-tag-nextjs
```

<Warning>
  Every rendered `<script>` tag **must** include a `data-code` attribute set
  to your Account ID (verification code). AdUnblock uses this value to verify
  that the script is running on your registered domain. Find your Account ID
  at the top of your AdUnblock dashboard.
</Warning>

## Basic Usage

Import and use the `ServerTag` component in your Next.js pages or layouts:

```tsx theme={null}
import ServerTag from "@adunblock/server-tag-nextjs";

export default function MyPage() {
  return (
    <div>
      <ServerTag
        remoteUrl="https://public.adunblocker.com/api/vendor_scripts"
        scriptAttributes={{ "data-code": "YOUR_ACCOUNT_ID" }}
      />
      <h1>My Page Content</h1>
    </div>
  );
}
```

## Advanced Usage

### Custom Caching

```tsx theme={null}
import ServerTag from "@adunblock/server-tag-nextjs";

export default function MyPage() {
  return (
    <div>
      <ServerTag
        remoteUrl="https://public.adunblocker.com/api/vendor_scripts"
        cacheInterval={600} // Cache for 10 minutes (default: 300 seconds)
      />
      <h1>My Page Content</h1>
    </div>
  );
}
```

### Custom Script Rendering

Override the default script rendering with a custom callback:

```tsx theme={null}
import ServerTag from "@adunblock/server-tag-nextjs";
import Script from "next/script";

export default function MyPage() {
  return (
    <div>
      <ServerTag
        remoteUrl="https://public.adunblocker.com/api/vendor_scripts"
        renderScript={(scripts) =>
          scripts.map((src) => (
            <Script
              key={src}
              src={src}
              strategy="lazyOnload"
              onLoad={() => console.log(`Loaded: ${src}`)}
            />
          ))
        }
      />
      <h1>My Page Content</h1>
    </div>
  );
}
```

## API Reference

### Props

| Prop               | Type               | Default     | Description                                                                                          |
| ------------------ | ------------------ | ----------- | ---------------------------------------------------------------------------------------------------- |
| `remoteUrl`        | `string`           | Required    | The URL to fetch script URLs from                                                                    |
| `cacheInterval`    | `number`           | `300`       | Cache duration in seconds                                                                            |
| `scriptAttributes` | `ScriptAttributes` | `undefined` | Attributes applied to every generated `<script>` tag. **Must include `data-code: YOUR_ACCOUNT_ID`.** |
| `renderScript`     | `function`         | `undefined` | Custom script rendering function                                                                     |

### Types

```typescript theme={null}
type ScriptAttributeValue = string | boolean | number | undefined;

interface ScriptAttributes {
  [key: string]: ScriptAttributeValue;
}

interface ServerTagProps {
  remoteUrl: string;
  cacheInterval?: number;
  scriptAttributes?: ScriptAttributes;
  renderScript?: (scripts: string[]) => React.ReactNode;
}
```

## Security

* Only HTTP and HTTPS URLs are allowed
* Server-side execution prevents client-side script injection
* URL validation prevents malicious protocol usage

## Browser Compatibility

This package works with all browsers supported by Next.js 15+ and React 19.


# PHP
Source: https://docs.ad-unblock.com/guides/php

Script loading for PHP applications with Laravel and Symfony support

Server-side script loading packages for PHP applications, providing secure, cached script loading with framework-specific integrations for Laravel and Symfony.

<Warning>
  Every rendered `<script>` tag **must** include a `data-code` attribute set
  to your Account ID (verification code). AdUnblock uses this value to verify
  that the script is running on your registered domain. Find your Account ID
  at the top of your AdUnblock dashboard.
</Warning>

## Available Frameworks

<CardGroup>
  <Card title="Laravel" icon="laravel">
    Blade helper function with built-in caching and auto-discovery
  </Card>

  <Card title="Symfony" icon="symfony">
    Twig extension with dependency injection and bundle structure
  </Card>
</CardGroup>

## Expected Remote Response Format

All PHP packages expect the remote URL to return JSON in this format:

```json theme={null}
["https://example.com/script1.js", "https://example.com/script2.js"]
```

## Laravel Integration

A Laravel package to fetch and render scripts from a remote URL with caching support.

**Repository**: [github.com/adunblock/adunblock-server-tag-laravel](https://github.com/adunblock/adunblock-server-tag-laravel)

### Installation

Install the package via Composer:

```bash theme={null}
composer require adunblock/server-tag-laravel:^1.0
```

The package will be automatically registered via Laravel's package auto-discovery feature.

<Note>
  Version 1.0+ is a stable release and doesn't require lowering `minimum-stability` in your `composer.json`.
</Note>

### Basic Usage

In your Blade template, you can now use the `server_tag` function. Pass your
Account ID (verification code) via the fourth argument:

```php theme={null}
<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {!!
    server_tag(
      'https://public.adunblocker.com/api/vendor_scripts',
      300,
      null,
      ['data-code' => 'YOUR_ACCOUNT_ID']
    )
  !!}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### With Caching

The second argument is the cache duration in seconds (default: `300`):

```php theme={null}
{!!
  server_tag(
    'https://public.adunblocker.com/api/vendor_scripts',
    600,
    null,
    ['data-code' => 'YOUR_ACCOUNT_ID']
  )
!!}
```

This caches the response for 10 minutes (600 seconds).

### Custom Rendering

You can provide a custom closure to the `render_script` argument to render the script tags in a different way:

```php theme={null}
<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {!!
    server_tag('https://public.adunblocker.com/api/vendor_scripts', 300, function($scripts) {
      $scriptTags = array_map(function ($src) {
        return "<script src=\"{$src}\" defer></script>";
      }, $scripts);
      return implode("\n", $scriptTags);
    })
  !!}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### Function Signature

```php theme={null}
server_tag(
    string $url,
    int $cache_seconds = 300,
    ?callable $render_script = null,
    ?array $script_attributes = null
): string
```

**Parameters:**

* `$url` (string): The remote URL to fetch scripts from
* `$cache_seconds` (int, optional): Cache duration in seconds. Default is `300`
* `$render_script` (callable, optional): Custom rendering function. Receives an array of script URLs and returns an HTML string
* `$script_attributes` (array, optional): Associative array of attributes applied to every generated `<script>` tag. **Must include `'data-code' => YOUR_ACCOUNT_ID`.** Defaults to `['async' => true]`.

### Laravel Features

* **Blade Helper Function**: Easy-to-use function for templates
* **Built-in Caching**: Automatic caching with configurable TTL
* **Auto-discovery**: Automatic service provider registration
* **Error Handling**: Graceful fallback to empty arrays
* **Security**: XSS protection with proper HTML escaping

### Laravel Requirements

* PHP 7.4 or higher
* Laravel 8/9/10/11/12

## Symfony Integration

A Symfony bundle to fetch and render scripts from a remote URL with Twig integration and caching support.

**Repository**: [github.com/adunblock/adunblock-server-tag-symfony](https://github.com/adunblock/adunblock-server-tag-symfony)

### Installation

Install the bundle via Composer:

```bash theme={null}
composer require adunblock/server-tag-symfony:^1.0
```

<Note>
  Version 1.0+ is a stable release and doesn't require lowering `minimum-stability` in your `composer.json`.
</Note>

Enable the bundle in your `config/bundles.php`:

```php theme={null}
<?php

return [
    // ... other bundles
    AdUnblock\ServerTag\Symfony\AdunblockServerTagBundle::class => ['all' => true],
];
```

### Basic Usage

In your Twig template, you can now use the `server_tag` function:

```twig theme={null}
<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {{ server_tag('https://public.adunblocker.com/api/vendor_scripts') }}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### With Caching

Add caching to reduce external requests by specifying cache duration in seconds:

```twig theme={null}
{{ server_tag('https://public.adunblocker.com/api/vendor_scripts', 300) }}
```

This caches the response for 5 minutes (300 seconds).

### Custom Rendering

You can provide a custom callable to the `render_script` parameter to customize how script tags are rendered:

```twig theme={null}
<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {{ server_tag('https://public.adunblocker.com/api/vendor_scripts', 300, custom_renderer) }}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### Function Signature

```php theme={null}
server_tag(string $url, int $cache_seconds = 0, ?callable $render_script = null): string
```

**Parameters:**

* `$url` (string): The remote URL to fetch scripts from
* `$cache_seconds` (int, optional): Cache duration in seconds. Default is 0 (no caching)
* `$render_script` (callable, optional): Custom rendering function. Receives an array of script URLs and returns an HTML string

### Symfony Features

* **Twig Integration**: Easy-to-use Twig function for templates
* **HTTP Client**: Uses Symfony's HTTP client for reliable requests
* **Caching**: Built-in caching support with configurable TTL
* **Error Handling**: Graceful error handling with fallback to empty arrays
* **Security**: XSS protection with proper HTML escaping
* **Bundle Structure**: Proper Symfony bundle with dependency injection

### Symfony Requirements

* PHP 7.4 or higher
* Symfony 5.0, 6.0, 7.0, or 8.0
* Twig 2.0 or 3.0

## Common Features

All PHP packages provide:

* ✅ **Remote Script Fetching**: Fetch JavaScript files from external URLs
* ✅ **Caching Support**: Built-in caching with configurable TTL
* ✅ **Error Handling**: Graceful fallback when remote URLs are unavailable
* ✅ **Security**: XSS protection with proper HTML escaping
* ✅ **Custom Rendering**: Support for custom script tag rendering

## Security Considerations

* **URL Validation**: Only HTTP and HTTPS URLs are allowed
* **XSS Protection**: All output is properly escaped
* **Error Handling**: Failed requests don't break page rendering
* **Caching**: Reduces load on remote servers

## Performance Tips

1. **Use Caching**: Configure appropriate cache intervals for your use case
2. **Error Handling**: Implement proper fallbacks for failed requests
3. **CDN Usage**: Use CDN URLs for better performance
4. **Cache Warming**: Pre-warm caches during deployment


# Python
Source: https://docs.ad-unblock.com/guides/python

Script loading for Python applications with Django support

Server-side script loading package for Python applications, providing secure, cached script loading with Django template tag integration.

## Django Integration

A Django package to fetch and render scripts from a remote URL with template tag integration and caching support.

### Installation

Install the package via pip:

```bash theme={null}
pip install adunblock-server-tag-django
```

<Warning>
  Every rendered `<script>` tag **must** include a `data-code` attribute set
  to your Account ID (verification code). AdUnblock uses this value to verify
  that the script is running on your registered domain. Find your Account ID
  at the top of your AdUnblock dashboard.
</Warning>

Add the `server_tag` app to your `INSTALLED_APPS` in your Django `settings.py`:

```python theme={null}
INSTALLED_APPS = [
    # ... other apps
    'server_tag',
]
```

### Cache Configuration

Configure caching in your `settings.py` (recommended for production):

#### Redis Cache (Production)

```python theme={null}
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
    }
}
```

#### Local Memory Cache (Development)

```python theme={null}
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-snowflake',
    }
}
```

### Basic Usage

In your view, pass the Account ID / verification code via the template
context:

```python theme={null}
# views.py
def home(request):
    return render(request, 'home.html', {
        'server_tag_attrs': {'data-code': 'YOUR_ACCOUNT_ID'},
    })
```

Then in your Django template, load the `server_tag_tags` and use the
`server_tag` tag with the `script_attributes` argument:

```html theme={null}
{% load server_tag_tags %}

<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {% server_tag "https://public.adunblocker.com/api/vendor_scripts" script_attributes=server_tag_attrs %}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### Custom Rendering

You can provide a custom Python function to the `render_script` parameter to customize how script tags are rendered:

#### Create Custom Template Tag

```python theme={null}
# my_app/templatetags/custom_tags.py
from django import template
from django.utils.safestring import mark_safe

register = template.Library()

@register.simple_tag
def custom_script_renderer(scripts):
    from django.utils.html import escape
    script_tags = [f'<script src="{escape(src)}" defer></script>' for src in scripts]
    return mark_safe('\n'.join(script_tags))
```

#### Use Custom Renderer in Template

```html theme={null}
{% load server_tag_tags %}
{% load custom_tags %}

<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {% server_tag "https://public.adunblocker.com/api/vendor_scripts" render_script=custom_script_renderer %}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

## Expected Remote Response Format

The remote URL should return a JSON response in this format:

```json theme={null}
[
  "https://example.com/script1.js",
  "https://example.com/script2.js"
]
```

## Django Features

* **Template Tag Integration**: Easy-to-use Django template tag
* **HTTP Client**: Uses requests library for reliable HTTP operations
* **Caching**: Built-in Django cache integration with configurable TTL
* **Error Handling**: Graceful error handling with fallback to empty arrays
* **Security**: XSS protection with proper HTML escaping
* **Django Integration**: Proper Django app structure with apps.py

## Advanced Usage

### Template Tag with Cache Control

```html theme={null}
{% load server_tag_tags %}

<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {% server_tag "https://public.adunblocker.com/api/vendor_scripts" cache_timeout=600 %}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### Conditional Script Loading

```html theme={null}
{% load server_tag_tags %}

<!DOCTYPE html>
<html>
<head>
  <title>My Page</title>
  {% if user.is_authenticated %}
    {% server_tag "https://public.adunblocker.com/api/vendor_scripts" %}
  {% else %}
    {% server_tag "https://public.adunblocker.com/api/vendor_scripts" %}
  {% endif %}
</head>
<body>
  <h1>My Page</h1>
</body>
</html>
```

### Using in Class-Based Views

```python theme={null}
from django.views.generic import TemplateView
from django.template.loader import render_to_string

class MyView(TemplateView):
    template_name = 'my_template.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        # You can also use the server_tag functionality in views
        context['page_title'] = 'My Custom Page'

        return context
```

## Configuration Options

The Django package supports several configuration options:

### Settings Configuration

You can configure default settings in your `settings.py`:

```python theme={null}
# Optional: Configure default cache timeout
SERVER_TAG_DEFAULT_TIMEOUT = 300  # 5 minutes

# Optional: Configure default HTTP timeout
SERVER_TAG_HTTP_TIMEOUT = 10  # 10 seconds

# Optional: Configure retry attempts
SERVER_TAG_RETRY_ATTEMPTS = 3
```

### Template Tag Parameters

The `server_tag` template tag accepts these parameters:

| Parameter           | Type       | Default  | Description                                                                                            |
| ------------------- | ---------- | -------- | ------------------------------------------------------------------------------------------------------ |
| `remote_url`        | `string`   | Required | URL to fetch script configuration from                                                                 |
| `cache_timeout`     | `number`   | `300`    | Cache duration in seconds                                                                              |
| `script_attributes` | `dict`     | `None`   | Attributes applied to every generated `<script>` tag. **Must include `'data-code': YOUR_ACCOUNT_ID`.** |
| `render_script`     | `function` | `None`   | Custom script rendering function                                                                       |

## Error Handling

The Django package includes robust error handling:

```python theme={null}
# In your Django settings, you can configure logging
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'ERROR',
            'class': 'logging.FileHandler',
            'filename': 'server_tag_errors.log',
        },
    },
    'loggers': {
        'server_tag': {
            'handlers': ['file'],
            'level': 'ERROR',
            'propagate': True,
        },
    },
}
```

## Security Considerations

* **URL Validation**: Only HTTP and HTTPS URLs are allowed
* **XSS Protection**: All output is properly escaped using Django's built-in functions
* **Error Handling**: Failed requests don't break template rendering
* **Caching**: Reduces load on remote servers and improves performance

## Performance Tips

1. **Use Redis**: Configure Redis caching for production environments
2. **Cache Warming**: Pre-warm caches during deployment
3. **Error Monitoring**: Monitor failed requests and adjust retry logic
4. **CDN Usage**: Use CDN URLs for better performance

## Requirements

* Python 3.8 or higher
* Django 3.2 or higher
* requests 2.25.0 or higher

## Common Patterns

### Base Template with Server Tags

```html theme={null}
<!-- base.html -->
{% load server_tag_tags %}

<!DOCTYPE html>
<html>
<head>
  <title>{% block title %}My Site{% endblock %}</title>
  {% server_tag "https://public.adunblocker.com/api/vendor_scripts" %}
  {% block extra_scripts %}{% endblock %}
</head>
<body>
  {% block content %}{% endblock %}
</body>
</html>
```

### Page-Specific Scripts

```html theme={null}
<!-- specific_page.html -->
{% extends "base.html" %}
{% load server_tag_tags %}

{% block extra_scripts %}
  {% server_tag "https://public.adunblocker.com/api/vendor_scripts" %}
{% endblock %}

{% block content %}
  <h1>Specific Page Content</h1>
{% endblock %}
```

## Next Steps

<CardGroup>
  <Card title="Test Implementation" icon="flask" href="/guides/test-with-chrome-extension">
    Test your Django integration with our Chrome extension
  </Card>

  <Card title="Node.js Integration" icon="node" href="/guides/nextjs">
    Learn about Node.js server-side integration
  </Card>
</CardGroup>


# React Router
Source: https://docs.ad-unblock.com/guides/react-router

Script loading for React Router applications with data and framework modes

A React Router component for server-side script loading and rendering designed for React Router's **data mode** and **framework mode**. This package provides secure, cached script loading with TypeScript support for server-side rendering.

## React Router Modes

This package is designed specifically for:

* **Data Mode**: Using `createBrowserRouter` with loaders
* **Framework Mode**: Using React Router with Vite plugin and SSR

<Warning>
  This package is for **server-side rendering only**. The script loader will
  throw an error if it runs in the browser, and it is not suitable for pure
  client-side applications.
</Warning>

## Installation

```bash theme={null}
npm install @adunblock/server-tag-react-router
```

<Warning>
  Every rendered `<script>` tag **must** include a `data-code` attribute set
  to your Account ID (verification code). AdUnblock uses this value to verify
  that the script is running on your registered domain. Find your Account ID
  at the top of your AdUnblock dashboard.
</Warning>

## Usage

### Data Mode with Custom Server

Using `server-tag-react-router` in "Data Mode" requires a custom server-side rendering (SSR) setup. The `serverTagLoader` is designed to run exclusively on the server.

#### 1. Define Your Routes (Shared)

This route configuration is used by both the server and the client.

```tsx theme={null}
// app/routes.tsx
import ServerTag, { serverTagLoader } from "@adunblock/server-tag-react-router";

// Your page component
function HomePage() {
  return (
    <div>
      <ServerTag scriptAttributes={{ "data-code": "YOUR_ACCOUNT_ID" }} />
      <h1>Home Page</h1>
    </div>
  );
}

export const routes = [
  {
    path: "/",
    element: <HomePage />,
    loader: () =>
      serverTagLoader({
        remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
        cacheInterval: 300, // Optional: cache for 5 minutes
      }),
  },
];
```

#### 2. Create a Server Entrypoint

This file contains the server-side rendering logic, typically run in an Express or Node.js environment.

```tsx theme={null}
// entry.server.tsx
import { renderToString } from "react-dom/server";
import {
  createStaticHandler,
  createStaticRouter,
  StaticRouterProvider,
} from "react-router-dom/server";
import { routes } from "./app/routes";

export async function render(req: Request) {
  const { query, dataRoutes } = createStaticHandler(routes);
  const context = await query(req);

  if (context instanceof Response) {
    return context;
  }

  const router = createStaticRouter(dataRoutes, context);
  const html = renderToString(
    <StaticRouterProvider router={router} context={context} />
  );

  return new Response("<!DOCTYPE html>" + html, {
    status: context.statusCode,
    headers: { "Content-Type": "text/html" },
  });
}
```

#### 3. Create a Client Entrypoint

This file hydrates the server-rendered HTML in the browser.

```tsx theme={null}
// entry.client.tsx
import { hydrateRoot } from "react-dom/client";
import { createBrowserRouter, RouterProvider } from "react-router-dom";
import { routes } from "./app/routes";

// In a full setup, you would pass hydrationData to createBrowserRouter
const router = createBrowserRouter(routes);

hydrateRoot(
  document.getElementById("root")!,
  <RouterProvider router={router} />
);
```

### Framework Mode Usage (Optimal Solution)

For React Router applications using a framework with SSR (e.g., Vite's SSR plugin), `ServerTag` offers a powerful and seamless way to manage both global and per-route scripts.

Simply place the `<ServerTag />` component once in your root layout. It will automatically detect and render scripts loaded from **any active route's loader**, from the root down to the deepest child.

#### Example: Hybrid Approach

This example demonstrates loading a global analytics script from the root and a page-specific charting library for a dashboard page.

**1. Update Your Root Layout**

Place `<ServerTag />` in the `<head>` of your root layout. This single component will handle rendering all scripts.

```tsx theme={null}
// app/root.tsx
import ServerTag, { serverTagLoader } from "@adunblock/server-tag-react-router";
import { Outlet } from "react-router-dom";

export async function loader() {
  // Load global scripts for all pages
  return await serverTagLoader({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
  });
}

export default function Root() {
  return (
    <html>
      <head>
        <ServerTag scriptAttributes={{ "data-code": "YOUR_ACCOUNT_ID" }} />
        {/* ... other head elements */}
      </head>
      <body>
        <Outlet />
        {/* ... other body elements */}
      </body>
    </html>
  );
}
```

**2. Add a Page-Specific Loader**

In a specific route, add another loader. When combining with other page data, ensure that the object returned by `serverTagLoader` is spread into the final returned object from your loader.

```tsx theme={null}
// routes/dashboard.tsx
import { serverTagLoader } from "@adunblock/server-tag-react-router";

export async function loader() {
  const [scriptData, dashboardData] = await Promise.all([
    // Load scripts only for this page
    serverTagLoader({
      remoteUrl: `https://public.adunblocker.com/api/vendor_scripts`,
    }),
    // Load other page data
    fetch("https://api.example.com/dashboard").then((r) => r.json()),
  ]);

  // Spread the scriptData to make the scripts available
  return { ...scriptData, dashboardData };
}

export default function DashboardPage() {
  // ... page component using dashboardData
  return <div>Dashboard Content</div>;
}
```

## Expected Remote Response Format

The remote URL should return a JSON response in this format:

```json theme={null}
["https://example.com/script1.js", "https://example.com/script2.js"]
```

## Custom Script Rendering

Override the default script rendering with a custom callback:

```tsx theme={null}
import ServerTag from "@adunblock/server-tag-react-router";

function MyPage() {
  return (
    <div>
      <ServerTag
        async={false}
        renderScript={(scripts) => (
          <>
            {scripts.map((src) => (
              <script
                key={src}
                src={src}
                defer
                data-custom-attribute="server-loaded"
              />
            ))}
          </>
        )}
      />
      <h1>My Page Content</h1>
    </div>
  );
}
```

## API Reference

### ServerTag Component

| Prop               | Type               | Default     | Description                                                                                          |
| ------------------ | ------------------ | ----------- | ---------------------------------------------------------------------------------------------------- |
| `async`            | `boolean`          | `true`      | Toggles the `async` attribute on the script tag.                                                     |
| `scriptAttributes` | `ScriptAttributes` | `undefined` | Attributes applied to every generated `<script>` tag. **Must include `data-code: YOUR_ACCOUNT_ID`.** |
| `renderScript`     | `function`         | `undefined` | Custom script rendering function.                                                                    |

### Loader Function

#### `serverTagLoader(config)`

Async function for loading scripts in React Router loaders. Works with both data mode and framework mode.

**Parameters:**

* `config.remoteUrl` (string, required): The URL to fetch script URLs from
* `config.cacheInterval` (number, optional): Cache duration in seconds (default: 300)

**Returns:** `Promise<ServerTagLoaderData>`

**Usage Examples:**

```tsx theme={null}
// Simple loader
export const loader = () =>
  serverTagLoader({
    remoteUrl: "https://public.adunblocker.com/api/vendor_scripts",
  });

// Combined with other data
export async function loader({ params }) {
  const [scripts, data] = await Promise.all([
    serverTagLoader({
      remoteUrl: `https://public.adunblocker.com/api/vendor_scripts`,
      cacheInterval: 600,
    }),
    fetch("/api/data").then((r) => r.json()),
  ]);
  return { scripts, data };
}
```

### Types

```typescript theme={null}
type ScriptAttributeValue = string | boolean | number | undefined;

interface ScriptAttributes {
  [key: string]: ScriptAttributeValue;
}

interface ServerTagProps {
  async?: boolean;
  scriptAttributes?: ScriptAttributes;
  renderScript?: (scripts: string[]) => React.ReactNode;
}

interface ServerTagLoaderArgs {
  remoteUrl: string;
  cacheInterval?: number;
}

interface ServerTagLoaderData {
  scripts: string[];
}
```

## Server-Side Only Design

This package is designed exclusively for server-side rendering:

* **Loaders run on the server** during route resolution
* **Components render on the server** before hydration
* **Scripts are included in the initial HTML** for optimal performance
* **No client-side fetching** or dynamic script injection

## Security

* Only HTTP and HTTPS URLs are allowed
* URL validation prevents malicious protocol usage
* Server-side execution prevents client-side script injection
* Built-in error handling for failed requests

## Browser Compatibility

This package works with all browsers supported by React 19 and React Router DOM 7+ when used in server-side rendering contexts.


# Test With Chrome Extension
Source: https://docs.ad-unblock.com/guides/test-with-chrome-extension

Test your AdUnblock implementation using our Chrome extension

Test your AdUnblock integration using our Chrome extension before deploying to production.

<Info>
  **Where to find your verification code**: Your verification code is your
  **Account ID**, shown at the top of your AdUnblock dashboard.
</Info>

<Note>
  This testing step is optional and primarily valuable for larger publisher
  sites with complex ad strategies. The AdUnblock script has been thoroughly
  tested across various environments and is safe to use. Most sites can proceed
  directly to implementation without preliminary testing.
</Note>

<Steps>
  <Step title="Prerequisites">
    Before testing, ensure you have the following setup:

    * Register your site in the AdUnblock dashboard
    * Install an ad blocker extension (like AdBlock or AdBlock Plus) in Chrome
    * Verify the ad blocker is enabled for your test site
    * This setup is necessary to confirm AdUnblock works correctly by showing ads despite the ad blocker
  </Step>

  <Step title="Install Chrome Extension">
    Install the AdUnblock Devtool Chrome extension to test your integration:

    * Visit [**AdUnblock Devtool**](https://chromewebstore.google.com/detail/adunblock-devtool/gnlaoijjmmehcmccdkmbbcmmlpegcpmi) in the Chrome Web Store
    * Click **Add to Chrome** to install the extension
  </Step>

  <Step title="Test Your Website">
    Use the extension to test the AdUnblock script on your website:

    * Navigate to your website in Chrome
    * Click the **AdUnblock Devtool** extension icon in your browser toolbar
    * Enter your **Verification Code**: `YOUR_ACCOUNT_ID`
    * Enter the **Script URL**: `LATEST_SCRIPT_URL` (fetch the latest URL from: `https://public.adunblocker.com/api/vendor_scripts`)
    * Click **Apply to Current Tab**
    * The page will automatically reload with the AdUnblock script injected

    <Warning>
      Your verification code is domain-specific, so you can only test on your own registered website. This extension is for testing purposes only before implementing a permanent integration.
    </Warning>
  </Step>

  <Step title="Verify Integration">
    After the page reloads with the AdUnblock script, verify the following:

    ✅ **Website Functions Normally**: Your site should work without any issues

    ✅ **Ads Are Visible**: Ads should display even with an ad blocker installed

    If both conditions are met, your integration is successful! You can now proceed with implementing a permanent solution using one of our integration guides.
  </Step>
</Steps>

## Verification Code

Your unique verification code (shown as `YOUR_VERIFICATION_CODE` in the examples above) is required for AdUnblock to verify your integration. This code is specific to your registered domain.

## Available Script Sources

We provide multiple CDN endpoints to enhance reliability. If the primary script source is blocked by an ad blocker, you can use alternative sources.

<Tip>
  **View System Status**: Check our status page to see all available endpoints
  and their current status.
</Tip>

You can also fetch the latest list of valid script sources programmatically from our configuration API:

```
https://public.adunblocker.com/api/vendor_scripts
```

## Need Help?

If you're experiencing any issues with the integration, please contact our support team at [support@adunblock.com](mailto:support@adunblock.com).

## Next Steps

<CardGroup>
  <Card title="JavaScript Integration" icon="js" href="/guides/html-javascript">
    Implement AdUnblock with vanilla JavaScript
  </Card>

  <Card title="WordPress Integration" icon="wordpress" href="/guides/wordpress">
    Use our WordPress plugin for easy setup
  </Card>
</CardGroup>


# WordPress
Source: https://docs.ad-unblock.com/guides/wordpress

Easy WordPress plugin installation

## WordPress Plugin Installation

The official AdUnblock plugin is available in the WordPress repository at [https://wordpress.org/plugins/ad-unblock/](https://wordpress.org/plugins/ad-unblock/).

<Steps>
  <Step title="Download Plugin">
    Download the AdUnblock WordPress plugin from the WordPress repository or
    your dashboard.
  </Step>

  <Step title="Install Plugin">
    Upload and activate the plugin through your WordPress admin panel.
  </Step>

  <Step title="Configure Settings">
    Enter your verification code and customize the detection behavior.
  </Step>

  <Step title="Test Implementation">
    Use our testing tools to verify everything works correctly.
  </Step>
</Steps>

## Method 1: WordPress Admin Installation

### Install from WordPress Repository

1. Go to **Plugins > Add New** in your WordPress admin
2. Search for "Ad Unblock" or visit the [official plugin page](https://wordpress.org/plugins/ad-unblock/)
3. Click **Install Now** and then **Activate**

### Manual Installation

1. Download the plugin ZIP file from your AdUnblock dashboard
2. Go to **Plugins > Add New > Upload Plugin**
3. Choose the ZIP file and click **Install Now**
4. Click **Activate Plugin**

## Plugin Configuration

After installing the plugin, configure it through **Settings > AdUnblock**:

### Basic Settings

* **Verification Code**: Your AdUnblock verification code (from your dashboard)
* **Enable AdUnblock**: Toggle to enable/disable
* **Page Rules**: Choose where to show AdUnblock (all pages, specific URL patterns, categories, or tags)

### Message Settings

* **Message Type**: Overlay, banner, or redirect
* **Message Theme**: Light, dark, or custom
* **Custom Title**: Override default title
* **Custom Message**: Override default message text
* **Button Text**: Customize the action button text

### Advanced Options

* **Exclude Pages**: Specific pages to exclude
* **User Roles**: Which user roles to show messages to
* **Mobile Settings**: Mobile-specific configuration
* **Cache Compatibility**: Settings for caching plugins


# Introduction
Source: https://docs.ad-unblock.com/index

Everything you need to know about implementing and optimizing AdUnblock for your website.

Get started with AdUnblock and begin recovering your ad revenue today.

<CardGroup>
  <Card title="Getting Started" icon="rocket" href="/get-started">
    Start recovering your lost ad revenue in a few simple steps with
    dashboard-guided integration.
  </Card>

  <Card title="Configuration API" icon="code" href="/api-reference/fetch-config">
    Fetch AdUnblock latest configuration and script sources for your
    integration.
  </Card>
</CardGroup>

## Integration Guides

Choose your platform and follow our step-by-step integration guides.

<CardGroup>
  <Card title="Test With Chrome Extension" icon="chrome" href="/guides/test-with-chrome-extension">
    Test your AdUnblock integration using our Chrome extension before going live.
  </Card>

  <Card title="WordPress Integration" icon="wordpress" href="/guides/wordpress">
    Easy WordPress plugin installation from the official repository.
  </Card>

  <Card title="Next.js" icon="react" href="/guides/nextjs">
    React Server Components with TypeScript support
  </Card>

  <Card title="React Router" icon="react" href="/guides/react-router">
    Data mode and framework mode integration
  </Card>

  <Card title="Express" icon="server" href="/guides/express">
    Middleware for Express and Node.js applications
  </Card>

  <Card title="PHP (Laravel/Symfony)" icon="php" href="/guides/php">
    Blade helpers and Twig extensions
  </Card>

  <Card title="Python (Django)" icon="python" href="/guides/python">
    Template tags with Django cache integration
  </Card>

  <Card title="Others (HTML/JS)" icon="code" href="/guides/html-javascript">
    Simple HTML/JavaScript integration that works with any website.
  </Card>
</CardGroup>

## Need help with implementation?

Our support team is ready to assist you with any questions or issues.

<Card title="Contact Support" icon="headset" href="https://ad-unblock.com/contact">
  Get personalized help from our technical support team.
</Card>