Deciding on JS Parsing in Labrika

Understanding the Challenge: HTML vs. JavaScript Websites

When analyzing a website for SEO, one of the most critical considerations is how your content is delivered. Websites fall into two broad categories:

1. HTML-based websites: These sites serve content directly in the HTML source code. The structure is static, and all the key information (text, images, metadata) is readily available in the page’s raw source code.
   • Example: A traditional blog or small business website built with platforms like WordPress or Joomla.
   • SEO Benefit: Search engines can easily crawl and index content without additional rendering or delays.
2. JavaScript-based websites: These sites dynamically generate content in the browser using JavaScript. This means the HTML source code is often incomplete or even empty until JavaScript executes.
   • Example: A modern e-commerce platform built with frameworks like React or Angular, where product lists or descriptions are fetched dynamically from APIs.
   • SEO Challenge: Search engines must render the page and execute JavaScript to see the full content, a process that requires more time and resources.

Why Does This Matter for SEO?

Search engines like Google have invested heavily in improving their ability to crawl and index JavaScript-based content. However, this process is not foolproof. Here’s how search engines approach the two types of websites:

• HTML-based sites: Search engines read the HTML source and immediately access all relevant content, metadata, and links. This process is fast and reliable.
• JS-based sites: The engine must first fetch the HTML, then load and execute JavaScript, and finally render the page to see the full content. This involves multiple steps:
  • Fetching external JS files.
  • Resolving API calls for data.
  • Rendering the final layout.

Example Issue:

Consider an e-commerce site where product descriptions are loaded via JavaScript. If Googlebot doesn’t execute the JS properly, the descriptions won’t appear in the index, meaning users searching for specific products might never find the site in search results.

How to Check If Google Can See Your Website’s Content

Before deciding whether to enable JS parsing in Labrika, you need to confirm whether your content is visible to Google. Here are three detailed methods to perform this check:

1. Google Search Console’s URL Inspection Tool
   • Open Google Search Console and navigate to the URL Inspection tool.
   • Enter a specific page URL to see how Google has crawled it.
   • Check the “Crawled Page” section:
     • Does it display all visible content?
     • Are meta tags, structured data, and text present?

   Pro Tip: Look for discrepancies between what Google indexed and what users see. For JavaScript-heavy sites, missing elements may indicate rendering issues.

2. Search Google with the site: Operator
   • Go to Google and type site:yourdomain.com. This shows all pages that Google has indexed from your website.
   • Compare the number of indexed pages with the actual number of pages on your site.
   • Check the titles and descriptions of indexed pages: Are they accurate and complete?

   Key Insight: If critical pages or content are missing, it’s a strong indication that Google is struggling to render your JavaScript content.

Deciding Whether to Enable JS Parsing in Labrika

Once you know whether Google can see your content, you can make an informed decision about enabling JS parsing in Labrika. Here’s a step-by-step guide:

When to Enable JS Parsing

• Key content is dynamically generated: If product descriptions, blog articles, or internal links are built with JavaScript, you need JS parsing to ensure Labrika accurately analyzes your site.
• Critical SEO elements depend on JS: Meta tags, canonical URLs, or structured data that are inserted dynamically via JavaScript require JS parsing for proper analysis.
• You’ve verified that Google sees your content: If Google is successfully rendering your site, enabling JS parsing in Labrika will mirror this behavior and provide useful insights.

When to Skip JS Parsing

• Content is accessible in HTML: If all visible content is present in the raw HTML source, there’s no need for JS parsing, as it adds unnecessary complexity and cost.
• Google can’t see your content: If Google fails to index your dynamically generated content (based on the checks above), enabling JS parsing won’t fix the issue. Instead, you should focus on redesigning your website to deliver key content in HTML.

Why JS Parsing Costs More Credits

Parsing JavaScript requires significantly more computational resources than standard HTML analysis. Here’s why:

1. Simulating a Browser Environment:

   Labrika must create a virtual browser environment to execute JavaScript and render the full content. This includes handling layouts, API requests, and additional assets like fonts or images.

2. Additional Network Requests:

   Many JavaScript-heavy websites rely on APIs to fetch data dynamically (e.g., product information, user reviews). Each additional request increases the time and resources required to analyze a single page.

3. Processing Complexity:

   JS parsing often requires analyzing multiple layers of scripts, including third-party dependencies, to generate the final view.

As a result, analyzing JavaScript-heavy sites in Labrika consumes twice as many credits per page compared to HTML-only sites.

How Long Will JS Parsing Take?

Enabling JS parsing not only increases credit consumption but also significantly slows down the analysis process. Here’s what you can expect:

• Speed Comparison: JS parsing takes approximately 2–3 times longer than standard HTML analysis.
• Example for 1,000 Pages:
  • Without JS parsing: 0.5–1 hours.
  • With JS parsing: 2–6 hours, depending on site complexity and server response times.

This extra time is necessary to ensure the accuracy of the analysis, but it’s important to plan accordingly when working with larger sites.

How to Enable JS Parsing in Labrika

You can enable JavaScript-based analysis in your website settings.

• Go to the left menu
• Navigate to Settings
• Open the Common Settings tab
• Find the Crawler Settings section

Case Study: When Redesigning the Site Is Necessary

Let’s consider a real-world example:

Scenario:

An online furniture store built with React dynamically loads product descriptions and reviews via API calls. When tested in Google Search Console, key content (e.g., product details) doesn’t appear in the “Crawled Page” view.

Outcome:

• Enabling JS parsing in Labrika would accurately analyze the site, but Google still wouldn’t see the content due to blocked scripts and API delays.
• The long-term solution is to redesign the site to deliver product descriptions and critical metadata directly in the HTML.

If search engines can’t index your content, enabling JS parsing is a temporary fix for analysis but won’t improve your site’s SEO performance.

Why Choose HTML-Friendly Platforms

If you’re building or migrating a website, opt for a platform that delivers critical content in HTML. Examples include WordPress, Drupal, and Joomla. These platforms:

• Ensure fast and reliable SEO with content directly available in the HTML.
• Simplify analysis, reducing credit usage and analysis time.
• Avoid risks related to JavaScript rendering issues.