"crawled - currently not indexed" Error when using Blazor WebAssembly

[Abdulrhman5]

I have an ASP.NET Core Razor Pages website where most pages are purely server-rendered, and they’re all indexed by Google just fine. However, I have three pages that contain Blazor WebAssembly components, and these pages are crawled but not indexed by Google Search Console (Crawled - currently not indexed). And when I try to "REQUEST INDIXING" through GSC. I get the following error: "Oops! Something went wrong We had a problem submitting your indexing request. Please try again later."

Here’s an example page that throws an error when trying to request indexing:

@page "/exercises/left/{id:int?}"
@using Keyboardy.Backend.Client.Services
@model Keyboardy.Backend.Pages.Exercises.LeftModel


<section class="section">
    <h1> This is importent information </h1>
    <p> This is also important</p>

    <div id="interactive-section">
        <component type="typeof(Core.Blazor.KeyboardContainer)" render-mode="WebAssembly" />
    </div>
</section>

@section Scripts {
    <script src="~/_framework/blazor.webassembly.js"></script>
}

I’m aware that Google doesn’t execute or index client-side Blazor (WebAssembly) content, but in this case, I'm concerned with the HTML that is already rendered on the server, not client-side Blazor.

What I’ve tried:

• Other purely Razor Pages are indexed correctly.
• Tried delaying Blazor boot script (setTimeout before loading blazor.webassembly.js) and requested indexing, but I still got the "Oops! Something went wrong" error.
• Removed the line: <component type="typeof(Core.Blazor.KeyboardContainer)" render-mode="WebAssembly" /> And the problem presisted. So I guess the error is occurring because I am loading a ton of wasm files through this line <script src="~/_framework/blazor.webassembly.js"></script>
• Removed this <script src="~/_framework/blazor.webassembly.js"></script> and the error cleared.

What can I do to index pages that are server-side rendered HTML and contain Blazor client-side?

[yassine-krichen]

So, here’s the thing, Google hates pages that trigger heavy WASM loads during its “Request Indexing” fetch. The second Googlebot sees a giant waterfall of .wasm, .dll, _framework/* files, it bails or marks the page as “low priority,” even if the visible server-rendered HTML is perfectly fine.

And yeah, the “Oops! Something went wrong” error in GSC… that’s just Google quietly saying:

“Bro, I’m not running your Blazor bootloader.”

Now, here’s the important insight:

This has nothing to do with the HTML your Razor Page renders.
Google can index that.
It just hates the WASM payload loading at crawl time.

Even if the <component> is gone, the presence of the WebAssembly boot script is enough to make Google classify the page as “non-static / JS-dependent,” which it deprioritizes, or outright refuses for manual indexing.

Your observations confirm it:

• Remove <script src="~/_framework/blazor.webassembly.js"></script> → indexing works
• Put it back → indexing blows up
• That’s it. Case closed.

So what can you do?

✔️ 1. Defer Blazor loading in a way Googlebot never sees it

Googlebot doesn’t scroll, doesn’t interact, and doesn’t wait for dynamic JS triggers.

Instead of:

<script src="~/_framework/blazor.webassembly.js"></script>

…load WASM only after a real user interacts, e.g. click, scroll, or intersection observer.

Example lazy-load snippet:

<script>
document.addEventListener("DOMContentLoaded", () => {
    const section = document.getElementById("interactive-section");
    const observer = new IntersectionObserver(entries => {
        if (entries[0].isIntersecting) {
            const s = document.createElement("script");
            s.src = "/_framework/blazor.webassembly.js";
            document.body.appendChild(s);
            observer.disconnect();
        }
    });
    observer.observe(section);
});
</script>

Googlebot will never trigger that.
Real humans will.

Your server-rendered HTML = indexable.
Your Blazor WASM = loaded only when needed.

---

✔️ 2. Move Blazor WASM pages behind a separate route subtree

If these are just 3 interactive pages, another clean option is:

• /exercises/left/... → static Razor-only (indexable)
• /interactive/exercises/left/... → Blazor WASM (not indexable, no problem)

You link from the indexed page → interactive page.
Google sees the good page and moves on.

---

✔️ 3. Use SSR Blazor instead of WASM

I know, I know, maybe overkill, maybe not what you want.
But Google loves SSR, hates WASM.
Just saying.

---

✔️ 4. Add noindex to Blazor-heavy versions

Index the normal HTML version.
Let the interactive version remain unindexed.

---

In short, Googlebot sees WASM → assumes it needs JS execution → refuses indexing.
Nothing to do with your SSR HTML.

Fix: Lazy-load or conditional-load the Blazor WASM boot script so Google never sees it.

That’s it. No magic. Just Google being picky.

Hope this helps.

[Abdulrhman5]

Hi Yassine, thanks a lot for your response! 🙏

I actually tried suggestion 1 (lazy-loading _framework/blazor.webassembly.js). Unfortunately, it still didn’t work. I kept getting the same "Oops! Something went wrong" error when requesting indexing in GSC.

To debug this, I checked my server logs, and surprisingly, Googlebot is still requesting the .wasm files, even though the Blazor script is only supposed to be injected dynamically after the interactive section becomes visible on screen.

Here’s what Googlebot is still fetching:

I'm sure you are surprised as I am. Apparently, Blazor WebAssembly has no reliable way to remain completely “invisible” to Googlebot, even if WASM loading is fully deferred.

My understanding so far is that:

• Google can index server-rendered HTML

• But as soon as a page loads the Blazor WebAssembly boot script (even when deferred), GSC will throw “Oops! Something went wrong” error.

• Removing <script src="…/blazor.webassembly.js"> instantly clears the error.

So even if the important content is server-rendered, the presence of Blazor WASM seems to break indexing.

I understand that Googlebot will not render or index Blazor WebAssembly components, but their presence on an indexable page shouldn’t break indexing completely.

If I’m misunderstanding something, I’d really appreciate clarification.

[Abdulrhman5]

Here is what I end up doing:
Conditionally Load Blazor for Bots. Detect crawlers and skip loading the Blazor script entirely for them.
I don't believe this is the best way to use Blazor with SEO indexed pages, but it works.

@page "/exercises/left/{id:int?}"
@using Keyboardy.Backend.Client.Services
@model Keyboardy.Backend.Pages.Exercises.LeftModel
@{
    var userAgent = Request.Headers["User-Agent"].ToString().ToLower();
    var from = Request.Headers["From"].ToString().ToLower();
    var isGoogleBot =  
    userAgent.Contains("googlebot") || userAgent.Contains("crawler") || from.Contains("googlebot");

}

<section class="section">
    <h1> This is importent information </h1>
    <p> This is also important</p>

    <div id="interactive-section">
        <component type="typeof(Core.Blazor.KeyboardContainer)" render-mode="WebAssemblyPrerendered" />
    </div>
</section>

@section Scripts {
    @if (!isGoogleBot)
    {
        <script src="~/_framework/blazor.webassembly.js"></script>
    }
}

[Abdulrhman5]

By the way, check the result if you like: https://keyboardy.net/en.