# StyloBot-utsläppsserien

*Bot-detektorn borde inte stanna vid att tillåta/block. Denna artikel visar hur StyloBots klassificeringsresultat blir till applikationslogik i ASP*

[<img src="/articleimages/stylobot-logo.svg" alt="StyloBot" width="120" />](https://www.stylobot.net)

> **StyloBot-utsläppsserien**
> 
> 1. [**Behavior, Inte Identitet**](/blog/stylobot-fingerprint): varför StyloBot modellerar klienter beteendemässigt
> 2. **Behavior-Är medveten ASP.NET UI**: servern - skickade ut ytan över det upptäcktsresultatet
> 3. [**Att hitta och lösa gränslös tillväxt i långtids-, -- och / eller körande- -.-nätverk**](/blog/stylobot-release-reliability): den tillförlitlighetsdisciplin som gör motorn tråkig i produktionen
> 4. [**Behavior-Akvis typscript-UI**](/blog/typescript-sdk): Express , Fastify, och webbladerkomponenter
> 5. [**Sidecar-arkitekturen**](/blog/sidecar-architecture): hur detektoren kopplas till icke--.NET-skivor
> 6. [**Att lära sig bli snabbare**](/blog/stylobot-release-learning): adaptiv inlärningssystem, ,, fyra, M SK2, övningsminnet, ,, och bedömningsキャッシュen
> 7. [**Att testa det som inte stannar kvar**](/blog/stylobot-release-nondeterministic-testing): kontrolldisciplinen : en BDF-fielddriver regression M SK2 belastning , och kalibrering
> 8. [**StyloExtract - en lokal lärande HTML omvandlare till Markdown**](/blog/stylobot-release-styloextract): HTML, →, Markdown-lagret som paras med detektorn, ,, walkersbug lucidVIEW som fångade, M SK3, och den hundföda-loopan som gjorde det ärligt

StyloBots gränssnitt är ASP, ., NET-platta över Stylobot och ', det detekterade resultatet.., dess funktion är enkel.: gör att robotar och riskklassificering är tillgängliga där webbapplikationer faktiskt behöver dem.

<!--category-- ASP.NET, StyloBot, Bot Detection, Security, Architecture -->
<datetime class="hidden">2026-06-01T10:30</datetime>

# Inleiding

De flesta UX-system är blinda.

Denna artikel är den andra insatsen i StyloBots release-serie. [Behavior, Inte Identitet](/blog/stylobot-fingerprint) täcker modellen under systemet. Den här täcker den ASP- -.- -NET ytan som omvandlar modellen till applikationsbeteende

Anta att detektorn redan existerar

Det är vad StyloBots gränssnitt är för.

Så istället för att sätta friktionen på efter det faktumet, kan du forma upplevelsen i realtid.

- visa olika innehåll för människor och robotar
- göm high-värde i gränssnittet från misstänkta inspelningar
- lägga till friktion i riskfyllda flöden innan de blir missbrukade
- behålla fullföljning i kontroller medan sidan förblir kontexten

Den här artikeln handlar i synnerhet om att ASP.NET yta : tag-helpare, sidaM SK3 nivåer av upphöjning, , och server, - sidaintegration, M SK6 Det följer: [Behavior, Inte Identitet](/blog/stylobot-fingerprint), som förklarar beteendemodellet under det . Nästa artikel kommer att omfatta JavaScript och klienten

[TOC]

# ASP.NET ytan

Det här är hur beteendet ser ut.

![Tavlans längst uppe bar på styloboten.net: sammanräkningar till vänster , och till höger M SK3YOUMST4 Människor MST5 Okänt syn | MST6 | komponerad av sb | mst | 7 | badge | МST8 | sb · MST9 | självförtroende](stylobot-inline-badges.png?width=1100&format=webp&quality=70)

Den där högra "-", handens kluster, är tre taghelpare.`<sb-badge>`, `<sb-confidence>`, `<sb-risk-pill>`) läsning från samma per-frågadetektionsresultat skulle kontrollören fåM SK2 Samma data , uttryckt vid rendertid

Kernidén är enkel. Detektorn ska inte stanna vid " tillåta" eller " blockera

Det betyder:".

- Razor kan göra olika innehåll för människor, robotar , och specifika typer av robotar
- Formular kan inkludera lagerade skydd som honungsburkar som en del av sidan, inte som ett separat säkerhetssystem
- kontrollen kan införa samma upptäcktsresultat som den UI som redan används
- din ASP.NET-app kan reagera på vad applikationen gör, inte bara på vilka sessionen säger att vara

Om du vill ha det detekteringsmotorn historia, som redan finns i [Del 2](/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture) och [Del 3](/blog/botdetection-part3-as-simple-as-possible). Den här artikeln börjar med en lager ovanpå det där.

```mermaid
flowchart LR
    A[Incoming request] --> B[StyloBot middleware]
    B --> C[Risk score bot type and signals]
    C --> D[Tag helpers in Razor]
    C --> E[Controller and page policy]
    D --> F[Different rendered experience]
    E --> G[Allow block challenge or redirect]
```

## Varför är denna yta viktig?

Utan en gränssnittoberytta stannar det detekterade fast i infrastrukturen

Du kan logga in en poäng. Du kan kanske blockera ett begäran. Men du kan inte enkelt säga

- visa katalogen men gömma programmet
- göra login-formen annorlunda för hög risktrafik
- låta sökboter se crawl-vänliga metadata utan att ge över varje kommersiell signal
- att behandla AI-kralare som ett licenseringskonversation snarare än ett brutet bidrag

Det är därför ytan spelar roll.

Ibland är den rätta svaret en block.

- gömma rabattkoder från priskramare
- avlägsna Express-checkout från upphöjda risksessioner
- använda sökmetadata utan att avslöja kommersiella signaler
- tyst avlägsna newsletterupplägg från automatisering
- lägga till friktion vid misstänkta inlogningar utan att straffa vanliga användare

Det här är skillnadören i StyloBots gränssnitt. [Att lära sig bli snabbare](/blog/stylobot-release-learning).)

## Storefront exemplet

Denna artikel går genom ett exempel av ASP.NET Core MVC butiksfront som använder StyloBots gränssnittassistenter över sex sidor.

Samplesappen är avsiktligt liten: skapade produkter, några kategorier , utgångslistatM SK3 newslettern , och loginMSC5 Poängen är inte affärslogiken M SK6 Poängen är att visa hur robotklassificering blir en applikationslogik

Installera packagerna:

```bash
dotnet add package Mostlylucid.BotDetection
dotnet add package Mostlylucid.BotDetection.UI
```

Sedan koppla StyloBot upp i `Program.cs`:

```csharp
builder.Services.AddStyloBot(
    configureDashboard: dashboard =>
    {
        dashboard.BasePath = "/_stylobot";
        dashboard.AllowUnauthenticatedAccess = true; // dev only
    },
    configureDetection: detection =>
    {
        detection.ExcludeLocalIpFromBroadcast = false;
    });

// ...

app.UseStyloBot();
app.MapHub<StyloBotDashboardHub>("/_stylobot/hub");
```

Det räcker för att börja klassificera begäran och exponera resultatet till Razor, kontroller , och live-dashboarden. Om du vill ha den bara [Del 3 täcker det i mer detaljer](/blog/botdetection-part3-as-simple-as-possible).

## Ett kort exempel: login som lagerade försvar

Antekensidan är en bra mikro, eftersom den visar hela modellen i några rader.

```mermaid
flowchart TD
    A[Request for login page] --> B[Render page]
    B --> C[Bot sees warning]
    B --> D[Form is rendered]
    D --> E[Submission arrives]
    E --> F{Honeypot triggered?}
    F -->|Yes| G[Redirect to LoginDenied]
    F -->|No| H{IsBot?}
    H -->|Yes| G
    H -->|No| I[Authenticate user]
```

```html
<!-- Layer 1: bots see a deterrent message before the form -->
<sb-bot>
    <div class="alert alert-warning">Automated login attempts are detected and blocked.</div>
</sb-bot>

<form method="post" action="/Account/Login">
    <!-- Layer 2: hidden trap fields - humans leave them blank; bots fill everything -->
    <sb-honeypot prefix="hp" fields="2"></sb-honeypot>

    <input type="email" name="email" />
    <input type="password" name="password" />
    <button type="submit">Sign In</button>
</form>
```

```csharp
// Layer 3: server-side final check before any processing
if (HoneypotValidator.IsTriggered(HttpContext) || HttpContext.IsBot())
    return RedirectToAction("LoginDenied");
```

Boten ser en varning, ,, sen färdas honepotet om den skickar in information.,, så blir den avvisad från servern.-, om den på något sätt passerar de tidigare lagerna.

Resten av denna artikel utökar den idén genom en realistisk butiksfront

---


## kostnaden av att inte veta vem som är i affären

Det huvudsakliga kommersiella problemet är inte """, "" Bots "", eller """, i abstrakt form, ".", utan att olika typer av automation orsakar olika typer på skador.

**Prisskrapper.** De skördar produkternas namn, ,, priser, ,, beschreibunger, M SK2 och lagerdata så att konkurrenterna kan återhämta sig mot dig i nära och riktig tid.

**Vouchertester.** De bruterar” - ”, tvingar Rabattkoder tills de hittar giltiga koder“ , ” som sedan publiceras på kupongerforum och bryter marginalen “ . ”

**Credential stuffers.** De återskapar lekterade användarens namn -passord par i skalan. Till och med låga träffar blir anteckningstagande händelser när volymen är hög

**AI- övningskralare.** De skördar beteckningar, ,, recensioner, , och redaktionell kopia för modellernas utbildning.. Det är inte samma hotmodell som en checkout-attacker,

**Newsletterbehållare.** De undersöker anmeldningsformulär för att validera e-postadresser , giftpostlistar, eller testa för injektionssvårigheter.

Det här är inte samma problem.

---


## Page 1: Ladengolvet

Homepage är där många skräpare börjar.. De vill ha katalogen. . Ni vill ha en katalog som är användbar för människor och indexerad för att leta efter.

*Scenario: en priskrapper träffar `/`; ser ett neutralt katalog meddelande , ingen välkomnande kopia*

```html
<!-- Human visitors see the welcome message and category count -->
<sb-human>
    <p class="muted">Welcome! Browse @Model.Count products.</p>
</sb-human>

<!-- Bots see a neutral, non-committal message -->
<sb-bot fallback="hide">
    <p class="muted">Product catalogue.</p>
</sb-bot>

<!-- Search engine crawlers get structured metadata, not price data -->
<sb-gate bot-type="SearchEngine">
    <meta name="description" content="@Model.Count products across @categories categories." />
</sb-gate>

<!-- Verified bots (Googlebot etc.) see a specific indicator -->
<sb-gate bot-type="VerifiedBot">
    <div class="alert alert-info">Verified crawler detected. Serving crawl-optimised view.</div>
</sb-gate>

<!-- High-risk sessions see friction before the buy buttons -->
<sb-gate min-risk="High">
    <div class="alert alert-warning">Additional verification may be required at checkout.</div>
</sb-gate>
```

De ger ledtrådar, inte tillgångskontroller.. Pagen fungerar fortfarande, . Vad är det som förändrar omgivningen runt den? . Det gör sidan mindre användbar för systematisk skördning utan att försämra kundenupplevelsen.

Det här är också där crawlerdifferentiering spelar roll. Du vill verkligen ha Googlebot-indexerade produkter. Du kanske inte vill att varje automatiserad klient får samma kommersiell presentation som en människa som shopper.

---


## Page 2: Artikelsidan

Det är på produktdetails-sidan som kommersiellt syfte blir uppenbart. Det är också där priskrapper och kuponghämpar letar efter signaler de bryr sig om

*Scenario: en priskrapper landar på `/Product/Detail/12`; den ser inga rabattkoder , inget lägga till M SK2 till- kartknappen , och inget köpsignal för att agera på*

```html
<!-- Exclusive discount - only shown to low-risk, verified human visitors -->
<sb-gate max-risk="Low">
    <div class="alert alert-success">
        Member discount: use code LOYAL10 for 10% off today.
    </div>
</sb-gate>

<!-- Medium-risk visitors get a friction signal before the cart button -->
<sb-gate min-risk="Medium">
    <div class="alert alert-warning">
        We noticed some unusual activity from your network.
        You can still purchase. You may be asked to verify at checkout.
    </div>
</sb-gate>

<!-- Datacenter/VPN visitors lose the buy button -->
<sb-signal signal="ip.is_datacenter" condition="true">
    <p class="muted">Purchase unavailable from datacenter or VPN networks.</p>
</sb-signal>

<!-- Human-only: the add-to-cart button -->
<sb-gate human-only>
    <form method="post" action="/Cart/Add">
        <button type="submit" class="btn btn-success">Add to Cart</button>
    </form>
</sb-gate>

<!-- Detection mini-card for transparency -->
<sb-summary variant="card"></sb-summary>
<sb-confidence display="bar" width="180px"></sb-confidence>
```

Tre användbara mönster visas här.

**Loyalty targeting.** Bra bitar borde gå till bra tillfällen. Att visa Rabatter bara på låga nivåer - risktrafik minskar avfallet och minskar chanserna att skräpmästar eller kupongbots lyfter upp offret

**progressiv friktion.** Medel risk betyder inte automatiskt "blocking." Sammanätverken , integritetsbrowser, , och VPN-nätverk skapa allihop falska positivityderM SK5 En varning bevarar ofta försäljningen bättre än hårdt förnekande

**Signalen-utbredning på nivånM SK1** `ip.is_datacenter` är en råsignal, inte en riskbande . Ibland är det inte policyn du bryr dig om som är: " hur riskfylld denna besökare är i allmänhet ?" men | " går den här specifika egendomen mot en affärsregel

Om du vill ha arkitekturen bakom dessa signaler, [Del 2 täcker det bestämde detektionsröret](/blog/botdetection-part2-signature-pipeline-and-stylobot-architecture).

Den skillnaden går genom resten av proveret, riskbanden : formar stora UX-decisioner, ,, medan individuella signaler hanterar smalare policyregler.

---


## sida 3: Kasse

Checkout är den högsta måltavlan på platsen.. Automatisering av bedrägerier , Korttestning , Gutscheinmissbruk , och skriptade repetitioner sammanföras här

*Scenario: en kupong - testbot träffar `/Cart/Checkout`; ser ett dödt - slutar meddelanden , skickar ett honungsbehåller, -, fyller i formen och får ett tyst accepterat utan att göra något om försöket igen.*

```mermaid
flowchart TD
    A[Visitor reaches checkout] --> B{Human?}
    B -->|No| C[Show dead-end message]
    B -->|Yes| D{Risk band}
    D -->|Low| E[Express checkout]
    D -->|Elevated| F[Standard payment flow]
    D -->|High or above| G[Alternative path]
    E --> H[POST order]
    F --> H
    G --> H
    H --> I{Honeypot triggered?}
    I -->|Yes| J[Silent accept fake success]
    I -->|No| K[Process real order]
```

```html
<!-- Gate the entire checkout form on human-only detection -->
<sb-gate human-only>
    <form method="post" action="/Cart/Order">
        @Html.AntiForgeryToken()

        <!-- Honeypot trap fields - invisible to humans, irresistible to bots -->
        <sb-honeypot prefix="co" fields="2"></sb-honeypot>

        <!-- Express checkout only for trusted visitors -->
        <sb-gate max-risk="Low">
            <button type="submit" name="express" value="true" class="btn btn-success">
                Express Checkout
            </button>
        </sb-gate>

        <!-- Standard checkout available up to elevated risk -->
        <sb-gate max-risk="Elevated">
            <button type="submit" class="btn btn-primary">Proceed to Payment</button>
        </sb-gate>

        <!-- High-risk visitors get an alternative path -->
        <sb-gate min-risk="High">
            <p>Please call us to complete your order: 0800 123 456</p>
        </sb-gate>
    </form>
</sb-gate>

<!-- Bots see a dead end, not an error -->
<sb-bot>
    <p class="muted">Checkout is only available to human visitors.</p>
</sb-bot>
```

Och i kontrollen

```csharp
[HttpPost]
public IActionResult Order(OrderModel model)
{
    if (HoneypotValidator.IsTriggered(HttpContext))
    {
        // Silent accept - bot thinks the order succeeded
        return RedirectToAction("Confirmed");
    }

    return ProcessOrder(model);
}
```

Denna sida visar tre tekniker som arbetar tillsammans.

**Honigpot släpps bort.** Om en robot fyller dolda fält, så accepterar du tyst och släpper in begäran. Fehlerfeedback hjälper attackörerna att iteraM SK2 tystnaden slösar bort sin tid

**Risken** Express-checkout är ett nytto för trovärdighet, inte ett förutsägbart rätt

**Graceful degradation.** Ett enkelt meddelande är ofta operationellt bättre än en svår fel

---


## Page 4: logga in

logga in är en annan typ av hög

*Scenariot : en credential- med hjälp av skripta träffar `/Account/Login`; den ser aldrig formen , fyller med honungskålen `LoginDenied`.*

```html
<!-- High-risk sessions see friction before the form -->
<sb-gate min-risk="High">
    <div class="alert alert-danger">
        High-risk signals detected. Login attempts are logged and may be blocked.
    </div>
</sb-gate>

<!-- Bots see a deterrent message - but the form is still rendered below -->
<sb-bot>
    <div class="alert alert-warning">
        Automated login attempts are detected and blocked.
    </div>
</sb-bot>

<!-- Form is visible to everyone; the honeypot is the second layer -->
<form method="post" action="/Account/Login">
    @Html.AntiForgeryToken()
    <sb-honeypot prefix="hp" fields="2"></sb-honeypot>
    <div class="form-group">
        <label for="email">Email address</label>
        <input type="email" id="email" name="email" autocomplete="email" />
    </div>
    <div class="form-group">
        <label for="password">Password</label>
        <input type="password" id="password" name="password" autocomplete="current-password" />
    </div>
    <button type="submit" class="btn btn-primary">Sign In</button>
</form>
```

Controllern tillhandahåller den slutliga checken:

```csharp
[HttpPost]
public IActionResult Login(LoginModel model)
{
    if (HoneypotValidator.IsTriggered(HttpContext))
        return RedirectToAction("LoginDenied");

    if (HttpContext.IsBot())
        return RedirectToAction("LoginDenied");

    return Authenticate(model);
}
```

Nyckelpunkten är kostnadsmässig asymmetry. Ett falskt positivt på checkout kan förlora en affär . Ett felaktigt positivt vid login brukar kosta en återprobering . En misslyckad credential M SK3 att hosta ett attack kostar ett konto MSC4 Det betyder att denna slutpunkt kan rättfärdiga mer restriktiva straffningar

---


## Page 5: Newsletter

Att logga in på en newsletter är där AI- crawler-handling blir särskilt intressant, eftersom det rätta svaret ofta inte är: "block

*Scenario: GPTBot träffar `/Newsletter/Subscribe`; så ser den en data - licenseringsmessage istället för en subskryptionspitch*

AI-kralare försöker inte köpa produkter eller brute.

```html
<!-- Human pitch - only visible to real visitors -->
<sb-human>
    <p class="muted">
        Get exclusive deals and discount codes delivered to your inbox.
        Subscribe below. Unsubscribe any time.
    </p>
</sb-human>

<!-- AI crawlers get a licensing message, not a block -->
<sb-gate bot-type="AiBot">
    <div class="alert alert-info">
        This email subscription endpoint is for human readers.
        For data licensing enquiries please contact us directly.
    </div>
</sb-gate>

<!-- Other automated clients get a simpler message -->
<sb-bot>
    <sb-gate bot-type="AiBot" negate="true">
        <div class="alert alert-warning">
            Automated subscription attempts are discarded.
        </div>
    </sb-gate>
</sb-bot>

<!-- The form - visible to everyone, processed differently per visitor type -->
<div class="card">
    <form method="post" action="/Newsletter/Subscribe">
        @Html.AntiForgeryToken()
        <sb-honeypot prefix="nl" fields="3"></sb-honeypot>
        <div class="form-group">
            <label for="email">Your email address</label>
            <input type="email" id="email" name="email" autocomplete="email" />
        </div>
        <button type="submit" class="btn btn-success">Subscribe</button>
    </form>
</div>
```

Och i kontrollen

```csharp
[HttpPost]
public IActionResult Subscribe(string email)
{
    if (HoneypotValidator.IsTriggered(HttpContext) || HttpContext.IsBot())
    {
        // Silent accept: bot thinks it succeeded, no retry incentive
        return RedirectToAction("Thanks", new { real = false });
    }

    _mailingList.Subscribe(email);
    return RedirectToAction("Thanks", new { real = true });
}
```

Den `Thanks` syn kan vara identisk i båda fallen. Det viktiga är att den automatiserade klienten inte kan skilja framgång från en tyst avföring

Det är också här som robottypen spelar mest roll `AiBot` är inte bara ett annat fientligt etikett.

---


## Page 6: Min upptäckt

Den `/Me` sidan är utvecklaren- vändar till användbara sidan. Det besvarar den praktiska integrationens fråganM SK2 vad tycker StyloBot att denna begäran är

*Scenario: en utvecklare har precis lanserat StyloBot och vill verifiera att webbläsarens inspelning är mänsklig `curl` poäng som bot.*

```html
<!-- Full detection panel: confidence, risk, reasons, contributing detectors -->
<bot-detection-details collapsed="false"></bot-detection-details>

<!-- Individual components for custom layouts -->
<sb-badge variant="full"></sb-badge>
<sb-confidence display="both" width="100%"></sb-confidence>
<sb-risk-pill></sb-risk-pill>
<sb-summary variant="card"></sb-summary>
```

Det `<bot-detection-details>` panel is what stylobot.net renders on its own home page

![bot-detectionM SK1details panel gjord på stylobot.netMST3 Live Mst4 Detektorn med radar MST5 | MST6 bot sannolikhet Mst7 Väldigt låg risk M st8 tillåt policy M ST9 tre bidragande detektörer M S ST10 Högsta Botspanel här listar upp riktiga registrerade robotar](stylobot-live-detection.png?width=1100&format=webp&quality=70)

Och via `HttpContext` förlängning API:

```csharp
ViewBag.IsBot       = HttpContext.IsBot();
ViewBag.IsHuman     = HttpContext.IsHuman();
ViewBag.Probability = HttpContext.GetBotProbability();
ViewBag.RiskBand    = HttpContext.GetRiskBand();
ViewBag.BotType     = HttpContext.GetBotType();
ViewBag.BotName     = HttpContext.GetBotName();
ViewBag.Reasons     = HttpContext.GetDetectionReasons().ToList();
```

För att simulera olika klassificeringar under utvecklingen

```bash
# Simulate a search engine crawler
curl -H "ml-bot-test-mode: googlebot" http://localhost:5200/Me

# Simulate a high-risk scraper
curl -H "ml-bot-test-mode: scraper" http://localhost:5200/Me

# Real browser (Playwright, Chrome, etc.) scores as human
```

Bestämda `EnableTestMode: true` i `appsettings.Development.json` om du vill att de här rubrikerna ska bli hyllade.

---


## Etikettens hjälpmodell

StyloBots gränssnitt är litet i syfte. Primitiven är enkla ; kombinationerna är där flexibiliteten kommer ifrån

| Etikettbekymmer | | | Role || | Nyckliga attribut |
|---|---|---|
| `<sb-human>` | Interpreterar bara för människor | `fallback` ("visar"/" gömmer" när det inte är klassificerat ; okwendalo M SK4 visar) |
| `<sb-bot>` | Rendera bara för robotar | `fallback` (default : gömma
| `<sb-gate>` | Multi
| `<sb-signal>` | Single blackboard signal gate | `signal`, `condition`, `value`, `fallback`, `negate` |
| `<sb-honeypot>` | Osynliga fängsfällor | `prefix`, `fields` (1-3; standard
| `<sb-badge>` | Detektor-Statuschip  | `variant` ("
| `<sb-confidence>` | Bot sannolikhetsbar | `display` (" `width` |
| `<sb-risk-pill>` | Riskbandetikett | ingen |
| `<sb-summary>` | Kompakt detekteringskort | `variant` ("
| `<bot-detection-details>` | Full detection breakdown `collapsed` (bool), `view` ("defaultM SK1kompakt")  |

`<sb-gate>` är den generella

```html
<sb-gate human-only>...</sb-gate>
<sb-gate bot-only>...</sb-gate>
<sb-gate verified-only>...</sb-gate>
<sb-gate max-risk="Low">...</sb-gate>
<sb-gate min-risk="Medium">...</sb-gate>
<sb-gate bot-type="SearchEngine,VerifiedBot">...</sb-gate>
<sb-gate bot-type="AiBot" negate="true">...</sb-gate>
<sb-gate max-risk="Low" fallback="hide">...</sb-gate>
```

Riskband i ordning: `VeryLow`, `Low`, `Elevated`, `Medium`, `High`, `VeryHigh`, `Critical`.

`<sb-signal>` dörrarna direkt på rå svarta bordssignaler. `condition` attribut accepterar `exists`, `not-exists`, `true`, `false`, `equals`, `not-equals`, `gt`, `lt`, `gte`, `lte`, `contains`, `any-true`, och `all-true`.

```html
<sb-signal signal="ip.is_datacenter" condition="true">...</sb-signal>
<sb-signal signal="detection.probability" condition="gte" value="0.8">...</sb-signal>
```

Den viktiga konstruktionsvalen är att dessa hjälpmedel handlar om att rendera, inte blockera. De låter din applikation uttrycka sin policy i gränssnittet utan att förvandla varje osäkerhet till en förnekelse.

### Attityder för Controller och Razor Page

För servern-Seitenövervakning, StyloBot exponerar också handlingsfilter och sida-attributer . Om gränssnittlayret är M SK3 visa något annorlunda ," är det här layeret ♫ " göra något annorlunda ♫

**`[BlockBots]`** återvänder 403 för robotar - klassificerade begäran , med optionella tillåtningslistar

```csharp
[BlockBots]                                                         // block everything
[BlockBots(AllowSearchEngines = true)]                              // let Googlebot through
[BlockBots(AllowSearchEngines = true, AllowSocialMediaBots = true)] // SEO + social previews
[BlockBots(BlockCountries = "CN,RU", BlockVpn = true)]              // geo + network enforcement
```

Tillåt flaggor: `AllowVerifiedBots`, `AllowSearchEngines`, `AllowSocialMediaBots`, `AllowMonitoringBots`, `AllowAiBots`, `AllowGoodBots`, `AllowScrapers`, `AllowMaliciousBots`, `AllowTools`.

nätverksflagger: `BlockCountries`, `AllowCountries`, `BlockVpn`, `BlockProxy`, `BlockDatacenter`, `BlockTor`.

**`[RequireHuman]`** är striktare än `[BlockBots]`; bara krav som är klassificerade som människor är tillåtna genom

**`[AllowBots]`** frigör en handling från en kontroller `[BlockBots]`.

```csharp
[BlockBots]
public class AccountController : Controller
{
    public IActionResult Login() { }          // blocked

    [AllowBots]
    public IActionResult HealthCheck() { }    // passes through
}
```

**`[BotPolicy("name")]`** applicerar en namnlig policy , med optionell slutpunkt-nivåöverrider

```csharp
[BotPolicy("strict")]
[BotPolicy("strict", BlockThreshold = 0.75, MinConfidence = 0.85, ActionPolicy = "throttle-stealth")]
```

**`[BotDetector("names")]`** kör specifika detektorer inline utan att definiera en komplett policy.

```csharp
[BotDetector("UserAgent,Header,Ip", BlockThreshold = 0.8)]
```

**`[BotAction("name")]`** överrider reaktionen utan att ändra upptäcktspolitiken.

```csharp
[BotPolicy("default")]
[BotAction("challenge-captcha", FallbackAction = "block")]
public IActionResult Checkout() { }
```

**`[BlockIfSignal]`** och **`[RequireSignal]`** poort på individuella svarta bordssignaler.

```csharp
[BlockIfSignal("ip.is_datacenter")]
[RequireSignal("geo.country_code", Value = "GB")]
```

**`[SkipBotDetection]`** förbipassar detektorn helt för hälsokontroller och mätendepunkter.

### HttpContext-extensioner

Alla klassificeringsdata är tillgängliga direkt i kontroller, Razor Pages , och Minimal APIs:

```csharp
// Classification
bool isBot      = HttpContext.IsBot();
bool isHuman    = HttpContext.IsHuman();
bool isVerified = HttpContext.IsVerifiedBot();
bool isSearch   = HttpContext.IsSearchEngineBot();

// Scores
double prob       = HttpContext.GetBotProbability();   // 0.0 - 1.0
double conf       = HttpContext.GetBotConfidence();
RiskBand risk     = HttpContext.GetRiskBand();         // VeryLow ... Critical
ThreatBand threat = HttpContext.GetThreatBand();       // None ... Critical

// Bot identity
BotType? type = HttpContext.GetBotType();
string?  name = HttpContext.GetBotName();

// Network
bool isDc  = HttpContext.IsDatacenter();
bool isVpn = HttpContext.IsVpn();
string? cc = HttpContext.GetCountryCode();

// Raw signals (blackboard passthrough)
T? val = HttpContext.GetSignal<T>("ip.is_datacenter");

// Recommended action
bool allow   = HttpContext.ShouldAllowRequest();
bool block   = HttpContext.ShouldBlockRequest();
bool captcha = HttpContext.ShouldChallengeRequest();
```

I en minimal API slutpunkt:

```csharp
app.MapPost("/api/order", (HttpContext ctx, OrderModel order) =>
{
    if (ctx.IsBot() || ctx.GetRiskBand() >= RiskBand.High)
        return Results.Forbid();

    return Results.Ok(ProcessOrder(order));
});
```

Tagbekymmer och förlängningsmetoder läsas från samma per-request detection result , så det finns ingen andra detektionspass bara för att gränssnittet använder den

---


## Vad brädan visar

Bordbrädan vid: `/_stylobot` är den riktiga operationella bilden

- **Fingeravtryck**: separerade besökare genom ett sammanlagt fingeravtryck
- **Bot %**: proportion av bots traffic per slutpunkt
- **Splitter fältet**: mänskligt /bot-förhållande per slutpunkt
- **Din upptäcktspanel**: hur den nuvarande sessie klassificerades, inklusive orsaker och bidragande detektörer

![/_stylobot-dashboard på en live installering: sammanlagda sammanräkningar i titeln , trafik över tid M SK2 Live aktivitet genom signering ( människor och robotar , klassificerad i antal träffade träffar](stylobot-dashboard-landing.png?width=1100&format=webp&quality=70)

De splittra staplarna är särskilt användbara i praktiken. En produktsida som trendar mycket på botsnivån -dominant är troligtvis bortskrapad

Om du vill ha den lägre modellen, -, bakom de fingeravtryck och beteendevectorna,,, som är täckt i den första satsen i den här release-serien [Behavior, Inte Identitet](/blog/stylobot-fingerprint).

---


## Den ena-koppen för beteendet-medveten UX

Blocking/ tillåt är en strömbrytare . beteende- medvetenheten om UX är en dial

En strömbrytare förvandlar osäkerhet till smärta: falska positiva förlorar kunder och falska negativer spillar värdet . En knapp låter dig forma upplevelsen istället M SK2 Du kan gömma tjänster , långsamma flöden Mska4 ta bort höga Mka5 trovärdiga genvägar M Ska6 presentera alternativa vägar Mske7 och reservera hård blockering för fall som faktiskt rättfärdiga detMska8

Det är vad StyloBots gränssnitt är för.

Nästa i releaseserien: [**Att hitta och lösa gränslös tillväxt i långtids-, -- och / eller körande- -.-nätverk**](/blog/stylobot-release-reliability), den tillförlitlighetsrekonstruktion som gjorde StyloBots vektorliknande lager från en GB LOH-timbomb till något du kan lämna igång på en Pi oändligt. [**Behavior-Akvis typscript-UI**](/blog/typescript-sdk) tar samma detektionsresultat till Express, Fastify , och webbläsaren för klienten