# Jazui

> Jazui: prerender and SEO service for SPAs (Blazor, Angular, React, Vue...). It serves Google, AI bots and social networks the already rendered HTML of your site, with an SEO score, an AI bot policy, a hosted blog and metrics.

Source page: https://doc.astrolui.com/jazui

Prerender and SEO for SPAs: be seen in search engines, AI and social networks.

Be seen in search engines, AI and social networks.

**Jazui** is a **prerender and SEO service for SPAs** (Angular, React, Vue, Blazor, Svelte...). It serves Google, AI bots (ChatGPT, Claude, Perplexity...) and social networks the already rendered HTML of your site, **without touching your code**. It also tells you who visits you and what is failing, and spreads your content with a blog, AI with your own key and metrics. People never go through Jazui: they keep using your usual app. Jazui is built with AstrolUI.

## 1. The SPA problem

In a SPA the initial HTML is almost empty and the content is built by JavaScript in the browser (in Blazor WebAssembly the .NET runtime is downloaded first, too). Many bots don't run JavaScript, or run it late and with limits: the result is incomplete indexing, generic titles and descriptions, empty previews when a link is shared and AI answers that never cite your site.

Prerendering hands each bot an already rendered HTML version of the page, with its content, its **meta** and **Open Graph** tags and the real status code (200, 404, redirect...), without changing anything in the app.

## 2. How it works

- **A bot asks for a page**: Google, an AI bot or a social network asks for a URL of your site.
- **Your integration recognizes it**: In the CDN, the server or a middleware the bot is recognized by its user agent and, instead of serving the SPA, the page is requested from the Jazui API with your token.
- **Jazui renders it or serves it from cache**: It checks the token, the plan, the rules and that the site is verified. If the page is cached it returns it instantly; otherwise it opens it with Chrome, stores it and returns it.
- **The bot gets the full HTML**: With the real status code (200, 404, redirect...). If Jazui is slow or fails, the integration serves the normal site.

To start: create the account, add the site, verify the domain (DNS or meta tag) and connect the integration.

## 3. What it includes

- **Rendering with Chrome**: Opens your page like a person, waits for your JavaScript to finish and stores the HTML: desktop or mobile, a «page ready» selector and extra headers.
- **Cache and re-cache**: Instant answers from cache, automatic re-cache by days (account, site or rule), manual re-cache, an API to re-cache or purge on deploy and comparing the cache with the live site.
- **Rules**: Conditions on the URL or the bot with actions: exclude, cache days, render settings, ignore parameters, remove elements (cookie banners, chats), inject meta, Open Graph or JSON-LD, force the status code (301, 404, 410) or block bots. With templates and a tester.
- **SEO score per page**: From 0 to 100, with «Fix first», a Google and sharing preview, and history.
- **AI bots**: A policy per bot (allow, block, search only or no training) that generates robots.txt and llms.txt, and measurement of the visits coming from AI.
- **How AI sees you**: A scanner that compares what a bot without JavaScript sees with what a person sees.
- **AI suggestions**: Fix proposals for each page that can be applied as a rule.
- **Broken links and redirects**: Review of failing links and redirect chains.
- **Hosted blog**: Articles, categories, tags, translations, versions and scheduling; SEO for every article, Markdown for AI, RSS, sitemap and llms.txt. Your site reads it through the API.
- **Writing with AI**: Suggested topics, drafts and autopilot.
- **Distribution**: Posting to social networks (Bluesky, Mastodon, Telegram, Discord...) and IndexNow.
- **Site files**: Sitemaps, robots.txt and llms.txt hosted by Jazui.
- **Bot traffic**: Verified versus fake bots, most requested pages, visits from AI and plan usage.
- **Google Search Console**: Clicks, impressions and indexing inside the dashboard.
- **Notices and alerts**: Render errors, a Googlebot drop or a lower score, by email and webhook, plus a weekly report.
- **Teams and security**: Roles per site, two-step verification and plans with Stripe.
- **AI with your own key**: Anthropic, OpenAI, Gemini, Mistral, DeepSeek or compatible: Jazui does not charge for AI.

## 4. Integrations

Choose where bots are recognized. Each card opens its guide in the Jazui documentation.

- **ASP.NET Core**: The Jazui.AspNetCore package on the AstrolUI NuGet feed: a middleware for hosted Blazor and any SPA served by .NET 8 or later. If Jazui fails, the normal page is served.
- **IIS**: A URL Rewrite rule with Application Request Routing in web.config: for Blazor WebAssembly published as a static site.
- **Cloudflare Workers**: A Worker in front of your site: bots are handled at the edge and the request never reaches your server.
- **Vercel / Next.js**: Middleware for projects deployed on Vercel.
- **Netlify**: Edge Function for sites on Netlify.
- **Node.js / Express**: Middleware for Node servers.
- **nginx**: Proxy configuration for nginx.
- **Apache**: mod_rewrite and proxy rules for Apache.
- **For AI**: The Jazui documentation as llms.txt, so your AI assistant can help you integrate it.

## 5. Jazui in a Blazor app with AstrolUI

**Blazor served by ASP.NET Core** (hosted WebAssembly or Blazor Web App): install **Jazui.AspNetCore** from the same AstrolUI feed and add the middleware **before** the static files and the fallback. It is the most robust option: if Jazui is slow or fails, the bot gets the normal page. The token goes in the **Jazui__Token** environment variable.

```bash
dotnet nuget add source https://nuget.astrolui.com/v3/index.json --name AstrolUI
dotnet add package Jazui.AspNetCore
```

```csharp
// Program.cs of the ASP.NET Core app that serves the Blazor WebAssembly client
builder.Services.AddJazui(builder.Configuration);   // section "Jazui": Token, SiteUrl, Timeout...

var app = builder.Build();
app.UseForwardedHeaders();   // only behind a proxy or CDN
app.UseJazui();              // before the static files and the SPA fallback
app.UseStaticFiles();
app.MapFallbackToFile("index.html");
app.Run();

// Token: environment variable Jazui__Token (never in appsettings.json)
```

**Static Blazor WebAssembly on IIS**: add the «Jazui» rule as the **first** rule of the web.config the site already has (don't replace it: it carries the MIME types and Blazor's rules) and enable the ARR proxy and the server variables once per server. Behind Cloudflare, the bot IP comes from **{HTTP_CF_CONNECTING_IP}**. Turn the rule on once the site is verified in Jazui: with ARR, if Jazui answers with an error, the bot gets that error.

```html
<!-- First rule of <rewrite><rules>, before the Blazor SPA fallback. Full bot list:
     https://docs.jazui.com/example_config/iis_web.xml -->
<rule name="Jazui" stopProcessing="true">
  <match url=".*" />
  <conditions logicalGrouping="MatchAll">
    <add input="{HTTP_USER_AGENT}#{QUERY_STRING}" pattern="^[^#]*(?:googlebot|bingbot|gptbot|chatgpt|claudebot|perplexity|facebookexternalhit|linkedinbot|whatsapp|...)|#.*_escaped_fragment_" />
    <add input="{REQUEST_METHOD}" pattern="^(GET|HEAD)$" />
    <add input="{HTTP_X_JAZUI}" pattern=".+" negate="true" />
    <add input="{URL}" pattern="\.(js|mjs|css|map|json|xml|txt|ico|png|jpg|svg|woff|woff2|wasm|dll|dat|blat|br|gz|pdf)$" negate="true" />
  </conditions>
  <serverVariables>
    <set name="HTTP_AUTHORIZATION" value="Bearer [JAZUI_TOKEN]" />
    <set name="HTTP_X_JAZUI_URL" value="https://{HTTP_HOST}{UNENCODED_URL}" />
    <set name="HTTP_X_JAZUI_CLIENT_IP" value="{REMOTE_ADDR}" />  <!-- behind Cloudflare: {HTTP_CF_CONNECTING_IP} -->
    <set name="HTTP_COOKIE" value="" />
  </serverVariables>
  <action type="Rewrite" url="https://api.jazui.com/Render" appendQueryString="false" />
</rule>
```

```bash
rem Once per server, as administrator: ARR proxy and the server variables the rule writes
%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/proxy /enabled:"True" /commit:apphost
%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/rewrite/allowedServerVariables /+"[name='HTTP_AUTHORIZATION']" /+"[name='HTTP_X_JAZUI_URL']" /+"[name='HTTP_X_JAZUI_CLIENT_IP']" /+"[name='HTTP_COOKIE']" /commit:apphost
```

**On every page**, so the SEO score goes up and previews look right:

- A **<PageTitle>** and a **<HeadContent>** with description, canonical and Open Graph (AstrolTitle accepts HeadContent): Jazui keeps them in the rendered HTML.
- A URL of its own for each piece of content and each language (like /jazui and /jazui/es in these docs), in the sitemap. Jazui can host the sitemap, robots.txt and llms.txt, and manage AI bots.
- Don't make the main content depend on a click or a scroll: what isn't painted on load isn't indexed.
- After publishing important changes, re-cache from the dashboard or with the cache API.

```razor
<PageTitle>Product X | MyStore</PageTitle>
<AstrolTitle Icon="astrol-basket" Text="Product X">
    <HeadContent>
        <meta name="description" content="Short description that will appear in Google" />
        <meta property="og:title" content="Product X" />
        <meta property="og:description" content="Preview text for WhatsApp, LinkedIn, X..." />
        <meta property="og:image" content="https://mystore.com/img/product-x.jpg" />
        <link rel="canonical" href="https://mystore.com/product/x" />
    </HeadContent>
</AstrolTitle>
```

## 6. API

Every integration calls **GET https://api.jazui.com/Render?url=** with the full encoded URL (or in the **X-Jazui-Url** header) and **Authorization: Bearer** with the account render token or a site token, kept by convention in the **JAZUI_TOKEN** variable (or **Jazui__Token** in .NET). Optional: **botAgent**, **X-Jazui-Client-IP** (the bot IP) and **If-None-Match**. The response is delivered to the bot only if it carries **X-Jazui: true**; with **X-Jazui-Blocked** the bot is blocked (403) and in any other case the normal site is served. To avoid loops, integrations let through requests that already carry the **X-Jazui** header. Never expose the token on the client.

There are also cache APIs (re-cache, purge), signed webhooks, blog and site files: see [docs.jazui.com/api](https://docs.jazui.com/api).

```bash
curl "https://api.jazui.com/Render?url=https%3A%2F%2Fexample.com%2F&botAgent=integration-test" \
     -H "Authorization: Bearer $JAZUI_TOKEN" -i

# Deliver the response to the bot only if it carries  X-Jazui: true  (any status: 200, 301, 404...).
# X-Jazui-Blocked = blocked bot (403). Anything else, or a timeout: serve the normal site.
```

## 7. Plans

Jazui has a free plan and monthly or yearly paid plans with a free trial. Prices and the limits of each plan are always up to date at [jazui.com/plan](https://jazui.com/plan).

## 8. Links

- Documentation and integrations
- Dashboard: sites, rules, SEO score, blog and metrics