JSON-LD Implementation for SaaS Products in SaaS Marketing Optimization for AI Search

JSON-LD (JavaScript Object Notation for Linked Data) implementation for SaaS products involves embedding structured data scripts into websites to provide machine-readable context about SaaS offerings, enhancing visibility in AI-driven search engines like Google and emerging AI tools ¹⁵. Its primary purpose is to optimize SaaS marketing by enabling rich snippets, knowledge panels, and semantic understanding, which improve click-through rates and organic traffic in AI search environments where contextual relevance is paramount ⁶. This matters profoundly in SaaS marketing optimization for AI search, as AI algorithms prioritize structured data to deliver precise, entity-based responses, potentially boosting long-tail query performance by 20-40% and preparing SaaS brands for voice and conversational commerce ¹⁷.

Overview

JSON-LD emerged as a lightweight Linked Data format built on JSON, designed to add semantic context to data and make it interoperable across web-scale applications, REST APIs, and databases ²⁸. The fundamental challenge it addresses in SaaS marketing is the inability of traditional HTML content to communicate product attributes, pricing structures, and feature sets in ways that AI search engines can reliably interpret and surface in enhanced search results ¹. As search evolved from keyword matching to entity-based understanding, SaaS companies faced a critical gap: their sophisticated product offerings were invisible to the semantic layers powering AI-driven search experiences ⁵.

The practice has evolved significantly from basic Schema.org markup to sophisticated, dynamically-generated structured data that feeds AI knowledge graphs ². Initially, JSON-LD served primarily to enable rich snippets in Google search results, but it has transformed into a foundational element for AI search optimization, enabling SaaS products to appear in voice search results, conversational AI responses, and entity-based recommendations ¹⁷. This evolution reflects the broader shift from traditional SEO to AI-first marketing strategies, where structured data creates a “network of standards-based, machine-readable data” that allows AI systems to aggregate SaaS insights from disparate sources for more accurate recommendations ².

Key Concepts

Schema.org Vocabulary

Schema.org vocabulary provides the standardized framework for defining SaaS product attributes in JSON-LD markup ¹³. This vocabulary includes specific types like “SoftwareApplication” and properties such as “applicationCategory,” “operatingSystem,” and “offers” that describe SaaS products in machine-readable formats ⁴.

For example, a project management SaaS platform like Asana would implement Schema.org vocabulary to define itself as a “SoftwareApplication” with “applicationCategory” set to “BusinessApplication,” “operatingSystem” specified as “WebApplication,” and detailed “offers” objects containing pricing tiers ($10.99/user/month for Premium, $24.99/user/month for Business) with “priceCurrency” set to “USD” and “eligibleRegion” targeting specific markets ¹.

Structured Data Markup

Structured data markup refers to the machine-readable code embedded in web pages that provides explicit context about content, enabling search engines and AI systems to understand relationships between entities ¹⁵. Unlike traditional HTML that focuses on presentation, structured data separates semantic meaning from visual layout ⁵.

Consider a SaaS analytics tool like Mixpanel implementing structured data on its pricing page. The markup would include nested “Offer” objects for each plan (Free, Growth, Enterprise), with properties like “price” ($25/month), “priceCurrency” (“USD”), “priceValidUntil” (2025-12-31), and “availability” (“InStock”), allowing AI search engines to extract precise pricing information for comparison queries without parsing HTML tables ¹³.

Entity Recognition and Knowledge Graphs

Entity recognition involves AI systems identifying SaaS products as distinct nodes in knowledge graphs, connecting them to related entities like founders, features, competitors, and user reviews ¹⁶. This creates a semantic network that AI can traverse to answer complex queries ².

For instance, when Salesforce implements JSON-LD with “sameAs” properties linking to its LinkedIn, Twitter, and Crunchbase profiles, plus “founder” markup identifying Marc Benioff, AI systems build a comprehensive entity profile. When users query “CRM software founded by Marc Benioff,” the knowledge graph connections enable AI to surface Salesforce with rich context including founding date, headquarters location, and product categories ¹⁶.

Rich Results and Enhanced SERP Display

Rich results are enhanced search engine results page (SERP) displays that include visual elements like star ratings, pricing information, availability status, and product images beyond standard blue links ¹⁵. These results significantly improve click-through rates by providing immediate value to searchers ⁶.

A SaaS email marketing platform like Mailchimp implementing “aggregateRating” markup with a 4.5-star average from 12,847 reviews would display those stars directly in search results. Combined with “offers” markup showing “Free plan available” and “Paid plans from $13/month,” the rich result provides comprehensive information that increases qualified traffic by 25-35% compared to standard listings ¹⁵.

Dynamic Schema Generation

Dynamic schema generation involves programmatically creating JSON-LD markup from databases, CMS systems, or APIs rather than hardcoding static markup ⁴. This approach enables scalability for SaaS companies with multiple products, pricing tiers, or frequently updated features ¹.

A SaaS marketplace like G2 with 100,000+ software listings uses dynamic generation by connecting JSON-LD templates to their product database. When a new SaaS tool is added with attributes (category, pricing, reviews, features), the system automatically generates compliant “SoftwareApplication” markup including “offers” arrays pulled from live pricing APIs, “aggregateRating” calculated from recent reviews, and “applicationCategory” derived from taxonomy tags—all without manual coding ⁴.

Semantic Interlinking

Semantic interlinking connects SaaS product data to related entities through properties like “sameAs,” “isRelatedTo,” and “BreadcrumbList,” creating contextual relationships that AI systems use to understand product positioning and relevance ³⁶. This goes beyond simple hyperlinks to establish meaningful semantic connections ².

For example, Slack’s JSON-LD implementation uses “BreadcrumbList” to establish hierarchical relationships (Home > Products > Team Collaboration > Slack), “sameAs” to link authoritative profiles (Wikipedia, Wikidata, social media), and custom properties connecting to integration partners (Salesforce, Google Workspace, Microsoft Teams). When AI systems process queries like “team collaboration tools that integrate with Salesforce,” these semantic connections enable precise matching and contextual recommendations ¹⁴.

AI Search Optimization

AI search optimization leverages structured data to align SaaS marketing with how AI systems retrieve, rank, and present information in conversational interfaces, voice assistants, and LLM-powered search experiences ¹⁷. This extends beyond traditional SEO to optimize for entity salience and semantic relevance ⁷.

A cybersecurity SaaS like Cloudflare optimizing for AI search implements comprehensive JSON-LD including “SoftwareApplication” markup with detailed “featureList” properties (DDoS protection, CDN, SSL/TLS), “review” arrays with specific use cases (“Reduced our page load time by 40%”), and “FAQPage” schema answering common questions. When users ask ChatGPT or Google’s AI Overview “What’s the best CDN for reducing DDoS attacks?”, the structured data enables the AI to extract specific features and benefits, positioning Cloudflare in AI-generated responses with accurate context ¹⁷.

Applications in SaaS Marketing Contexts

Product Landing Page Optimization

SaaS companies implement JSON-LD on product landing pages to enhance visibility for feature-specific searches and enable rich results displaying key product attributes ¹⁵. A marketing automation platform like HubSpot embeds “SoftwareApplication” schema on its Marketing Hub landing page, including “applicationCategory” (“MarketingAutomation”), detailed “offers” with tiered pricing ($45/month Starter, $800/month Professional, $3,200/month Enterprise), “aggregateRating” (4.4 stars from 3,892 reviews), and “featureList” (email marketing, landing pages, marketing analytics). This markup enables the page to appear in rich results for queries like “marketing automation software pricing” with star ratings and price ranges displayed directly in SERPs, increasing qualified traffic by 30-40% ¹⁵.

SaaS Directory and Comparison Sites

Directory publishers and comparison platforms use template-based JSON-LD generation to scale structured data across thousands of SaaS listings ⁴. Capterra, listing 50,000+ software products, implements a dynamic system where each SaaS profile automatically generates “SoftwareApplication” markup pulling from their database: product name, vendor information via “Organization” schema, “offers” from pricing data, “aggregateRating” calculated from user reviews, and “applicationCategory” from taxonomy. When users search “best CRM under $50/month,” Google can parse structured data across all listings to surface relevant options with pricing and ratings, while AI search tools extract comparison tables from the semantic markup ⁴.

Pricing Page Enhancement

SaaS pricing pages benefit significantly from detailed “Offer” schema that enables AI systems to understand subscription models, pricing tiers, and feature differentiation ¹. Notion implements JSON-LD on its pricing page with separate “Offer” objects for each plan: Free (price: 0, eligibleCustomerType: “Individual”), Plus (price: 8, priceCurrency: “USD”, billingIncrement: “month”, eligibleQuantity: “unlimited”), Business (price: 15), and Enterprise (price: “Contact Sales” with priceSpecification: “Custom”). Each offer includes “itemOffered” with “featureList” detailing what’s included. This structured approach allows AI search to answer queries like “Notion pricing for teams” with accurate tier information and feature comparisons extracted directly from the markup ¹³.

Review and Testimonial Integration

Implementing “Review” and “AggregateRating” schema transforms customer testimonials into structured data that influences both traditional search rankings and AI-generated recommendations ¹⁵. A SaaS customer support platform like Zendesk embeds individual “Review” objects within their “SoftwareApplication” markup, each containing “author” (reviewer name and organization), “reviewRating” (1-5 stars), “reviewBody” (detailed testimonial), and “datePublished”. The aggregate schema calculates “ratingValue” (4.3), “reviewCount” (8,234), and “bestRating” (5). This enables rich snippets showing star ratings in search results and provides AI systems with sentiment data to include in responses to queries like “What do users say about Zendesk’s ease of use?” ¹⁵.

Best Practices

Start with Core Schema Types and Expand Incrementally

Begin JSON-LD implementation with foundational schema types like “Organization” and “SoftwareApplication” before adding complex nested structures ⁵. This approach ensures basic entity recognition while minimizing errors that could invalidate all markup. The rationale is that search engines prioritize correctly implemented basic schemas over incomplete complex ones, and incremental expansion allows for testing and validation at each stage ¹⁶.

For implementation, a SaaS startup should first deploy “Organization” schema on their homepage including “name,” “url,” “logo,” “sameAs” (social profiles), and “contactPoint.” Once validated via Google’s Rich Results Test, add “SoftwareApplication” to the main product page with essential properties: “name,” “applicationCategory,” “operatingSystem,” and basic “offers.” After monitoring Search Console for 2-4 weeks to confirm indexing, expand to include “aggregateRating,” detailed “featureList,” and multiple “offers” for different pricing tiers. This staged approach reduces risk while building toward comprehensive coverage ⁵.

Implement Real-Time Data Synchronization

Connect JSON-LD markup to live data sources rather than maintaining static schemas to ensure accuracy and avoid penalties for outdated information ¹⁴. AI search systems increasingly verify structured data against actual page content and external sources, making synchronization critical for maintaining trust signals and rich result eligibility ⁶.

A SaaS company should integrate their JSON-LD generation with their pricing database and CRM system. For example, connect the “offers” schema to Stripe or Chargebee APIs so that when subscription prices change, the markup updates automatically. Similarly, link “aggregateRating” to review platforms like G2 or Trustpilot via API, recalculating ratings weekly. Implement webhooks that trigger schema regeneration when product features are added in the CMS. This real-time approach prevented one SaaS analytics platform from losing rich results when they updated pricing but forgot to update static JSON-LD, which had shown outdated prices for three months ¹⁴.

Validate Rigorously and Monitor Continuously

Use Google’s Rich Results Test, Schema Markup Validator, and Search Console to validate JSON-LD before deployment and monitor performance post-implementation ⁶. Validation catches syntax errors, missing required properties, and guideline violations that prevent rich results, while ongoing monitoring identifies indexing issues and measures impact on search visibility ¹.

Before deploying JSON-LD to production, test markup using Google’s Rich Results Test to confirm eligibility for enhanced displays, then validate JSON syntax using JSONLint to catch formatting errors. After deployment, set up Search Console monitoring with weekly checks of the “Enhancements” report to track rich result impressions, clicks, and errors. Create alerts for sudden drops in structured data coverage. A B2B SaaS company discovered through monitoring that their “aggregateRating” markup was rejected because “ratingValue” exceeded “bestRating” (showing 5.2 out of 5), which they corrected within 48 hours, restoring rich snippets that drove 22% of their organic traffic ¹⁶.

Align Markup with User Intent and AI Query Patterns

Structure JSON-LD properties to match how users phrase queries in AI search interfaces and voice assistants, not just traditional keyword searches ⁷. AI systems extract specific attributes from structured data to answer conversational queries, so markup should anticipate natural language patterns and question-based searches ¹.

When implementing “SoftwareApplication” schema for a project management SaaS, include detailed “featureList” properties using natural language that matches how users ask questions: instead of technical terms like “Gantt visualization,” use “timeline view for project planning” and “task dependency tracking.” Add “FAQPage” schema addressing common questions: “Does it integrate with Slack?” “Can I use it offline?” “What’s the learning curve?” This approach helped a collaboration SaaS capture 35% more traffic from voice searches and AI Overview features by aligning their structured data with conversational query patterns like “project management software that works offline and integrates with Slack” ¹⁷.

Implementation Considerations

Tool and Format Selection

Choose implementation tools based on technical resources, scale, and CMS platform ³⁵. Options range from manual coding for maximum control to CMS plugins for ease of use, and programmatic generation for enterprise scale. WordPress sites can leverage Yoast SEO or Rank Math plugins that provide GUI interfaces for generating JSON-LD without coding, suitable for small SaaS companies with limited technical resources ⁵. Mid-sized companies using custom CMSs might implement templating systems with Jinja2 or Twig that pull product data from databases into JSON-LD templates, balancing automation with customization ⁴. Enterprise SaaS with thousands of SKUs should build API-driven systems connecting to product information management (PIM) platforms, generating schemas dynamically and updating in real-time ¹.

For format choices, JSON-LD is strongly preferred over Microdata or RDFa because it separates structured data from HTML, preventing layout conflicts and enabling easier programmatic generation ⁵. A SaaS company migrating from Microdata to JSON-LD reported 40% faster implementation time and eliminated rendering issues on mobile devices ¹⁰.

Audience-Specific Customization

Tailor JSON-LD properties to target audience segments and their search behaviors ¹. B2B SaaS targeting enterprise buyers should emphasize different attributes than B2C SaaS targeting individual consumers. For enterprise-focused SaaS, implement detailed “offers” with “eligibleCustomerType” specifying business segments, “priceSpecification” for volume licensing, and “termsOfService” linking to SLAs and compliance documentation. Include “Organization” schema with “numberOfEmployees,” “foundingDate,” and security certifications in “award” properties to build trust signals ¹.

Conversely, a consumer-focused SaaS like Canva should emphasize “aggregateRating,” individual “Review” objects with relatable use cases, “offers” highlighting free tiers, and “featureList” using accessible language. Geographic customization matters too: implement “eligibleRegion” in “offers” to specify availability, and use “inLanguage” properties for multilingual SaaS serving global markets. A language learning SaaS increased international organic traffic by 28% after implementing region-specific JSON-LD with localized “offers” and “inLanguage” properties for each market ¹.

Organizational Maturity and Resource Allocation

Align JSON-LD implementation complexity with organizational SEO maturity and available resources ¹⁴. Early-stage SaaS startups with limited technical teams should focus on essential schemas (Organization, SoftwareApplication, basic Offers) using CMS plugins or simple templates, allocating 10-15 hours for initial setup and monthly validation ⁵. Growth-stage companies with dedicated marketing teams can invest in custom templating systems, API integrations, and comprehensive schema coverage across all product pages, requiring 40-60 hours for initial implementation plus ongoing maintenance ⁴.

Enterprise SaaS organizations should build sophisticated programmatic systems with dedicated engineering resources, implementing advanced schemas (FAQPage, HowTo, VideoObject for tutorials), A/B testing different markup approaches, and integrating with marketing automation platforms. One enterprise SaaS allocated a full-time engineer for three months to build a comprehensive JSON-LD system connected to their PIM, CRM, and review platforms, resulting in 45% increase in organic visibility and 30% improvement in qualified lead generation from search ¹⁴.

Common Challenges and Solutions

Challenge: Syntax Errors and Validation Failures

JSON-LD implementation frequently fails due to syntax errors like missing commas, unclosed brackets, incorrect property names, or invalid data types that prevent search engines from parsing the markup ¹⁶. These errors are particularly common when manually coding schemas or when dynamic generation systems produce malformed JSON. A single syntax error can invalidate entire schema blocks, eliminating rich result eligibility and wasting implementation effort. SaaS companies often discover validation failures weeks after deployment, losing potential traffic during that period ⁶.

Solution:

Implement a multi-layer validation process combining automated testing, staging environment checks, and production monitoring ¹⁶. Before deployment, validate all JSON-LD using JSONLint to catch syntax errors, then test with Google’s Rich Results Test to confirm schema eligibility and identify property-level issues. For dynamic generation, build unit tests that validate sample outputs against Schema.org specifications, running automatically with each code deployment. In staging environments, use the Schema Markup Validator to test across different page types and data scenarios.

For example, a SaaS company building dynamic “SoftwareApplication” schemas should create test cases covering edge scenarios: products without reviews (omit “aggregateRating”), free-only offerings (price: 0), and enterprise plans (price: “Contact Sales”). Implement error handling that gracefully degrades when data is missing rather than producing invalid JSON. Set up Search Console monitoring with weekly reviews of the “Unparsable structured data” report, creating alerts for sudden increases in errors. One project management SaaS reduced validation errors from 23% to under 2% by implementing automated testing that caught issues like “ratingValue” being passed as strings instead of numbers ¹⁶.

Challenge: Dynamic Data Staleness

SaaS products frequently update pricing, features, availability, and reviews, but JSON-LD markup often remains static, creating discrepancies between structured data and actual page content ¹⁴. Search engines increasingly verify structured data against visible content and may penalize or ignore markup that doesn’t match reality. Stale pricing in “offers” schema can mislead users and violate Google’s guidelines, while outdated “aggregateRating” fails to reflect current product quality ⁶.

Solution:

Implement automated synchronization between data sources and JSON-LD generation, with update frequencies matching content change patterns ¹⁴. Connect “offers” markup to pricing databases via APIs, regenerating schemas whenever prices change. For subscription-based SaaS, implement daily or weekly updates to ensure promotional pricing and seasonal changes reflect accurately. Link “aggregateRating” to review platforms with weekly recalculation of average scores and review counts.

A practical implementation for a SaaS analytics platform involves setting up webhooks from Stripe that trigger schema regeneration when pricing plans are modified, ensuring “offers” updates within minutes. Connect to G2’s API to pull review data weekly, automatically updating “aggregateRating” and adding recent “Review” objects. For feature updates, integrate with the product management system (like Productboard) so that when features are marked as “Released,” they automatically populate “featureList” properties. Implement version control for schemas with rollback capabilities if automated updates produce errors. This approach helped a marketing automation SaaS maintain 99.8% accuracy between structured data and actual content, preserving rich result eligibility and user trust ¹⁴.

Challenge: Over-Markup and Guideline Violations

SaaS marketers sometimes implement excessive or misleading structured data to manipulate search results, such as inflating ratings, marking up invisible content, or using irrelevant schema types ¹⁶. Google’s structured data guidelines explicitly prohibit marking up content not visible to users, using markup for deceptive purposes, or implementing schemas that don’t accurately represent page content. Violations can result in manual actions, loss of rich results, or broader ranking penalties ⁶.

Solution:

Adhere strictly to Google’s structured data guidelines and Schema.org specifications, implementing only markup that accurately represents visible, relevant content ¹⁶. Conduct quarterly audits comparing JSON-LD properties against actual page content to ensure alignment. Avoid marking up promotional claims as “Review” objects, inflating “aggregateRating” beyond actual scores, or implementing “offers” for products not genuinely available.

For implementation, create internal guidelines specifying that “Review” schema should only include verified customer testimonials visible on the page, “aggregateRating” must match displayed review platforms exactly (with source attribution), and “offers” should reflect current, publicly available pricing. When implementing “SoftwareApplication” schema, ensure every property in “featureList” corresponds to features actually described on the page. Avoid using multiple schema types that don’t genuinely apply (e.g., marking a SaaS product as both “SoftwareApplication” and “Course” unless it’s genuinely both).

A B2B SaaS company received a manual action for marking up testimonials from their sales deck (not visible on the website) as “Review” objects. After removing non-visible reviews, ensuring “aggregateRating” matched their G2 profile exactly, and limiting “offers” to publicly listed plans, they successfully requested reconsideration and restored rich results within three weeks. They now conduct monthly audits using a checklist that verifies each schema property against visible content ¹⁶.

Challenge: Mobile Rendering and Performance Issues

JSON-LD scripts can impact page load times, particularly on mobile devices where performance is critical for both user experience and search rankings ⁶. Large schema objects with extensive nested properties, multiple schema types per page, or inefficient implementation methods can add 200-500ms to load times. Additionally, client-side JavaScript that generates JSON-LD dynamically may not execute before search engine crawlers parse the page, resulting in missing structured data ³⁵.

Solution:

Optimize JSON-LD implementation for performance by minimizing schema size, using server-side rendering, and implementing lazy loading for non-critical schemas ³⁵. Compress JSON-LD by removing unnecessary whitespace and limiting properties to those that provide genuine value for search visibility. Prioritize server-side rendering over client-side generation to ensure schemas are present in initial HTML, guaranteeing crawler access ⁵.

For practical implementation, audit current JSON-LD file sizes and identify optimization opportunities. A SaaS company with 15KB of JSON-LD per page reduced it to 6KB by removing redundant properties, consolidating multiple “Organization” schemas into one, and eliminating overly detailed “featureList” entries that provided minimal search value. Implement server-side rendering using Next.js, Nuxt.js, or traditional server-side languages to generate JSON-LD before page delivery. For pages with multiple schema types, prioritize critical schemas (SoftwareApplication, Organization) in the initial HTML and lazy-load supplementary schemas (FAQPage, HowTo) after primary content renders.

Test mobile performance using Google PageSpeed Insights and Search Console’s Mobile Usability report. One SaaS platform reduced mobile load time by 340ms by moving JSON-LD generation from client-side React to server-side Next.js, improving their Core Web Vitals scores and increasing mobile organic traffic by 18% ³⁵.

Challenge: Keeping Pace with Schema Evolution

Schema.org vocabulary and search engine requirements evolve continuously, with new properties, types, and guidelines emerging regularly ⁶. SaaS companies implementing JSON-LD face the challenge of maintaining current schemas while adapting to new opportunities like emerging AI search platforms, updated rich result eligibility criteria, and expanded Schema.org vocabularies. Failure to adapt means missing new visibility opportunities and potentially using deprecated properties ¹.

Solution:

Establish a structured process for monitoring schema updates and implementing relevant changes quarterly ¹⁶. Subscribe to Schema.org release notes, Google Search Central blog, and SEO industry publications to track changes. Conduct quarterly schema audits comparing current implementation against latest Schema.org specifications and Google’s rich result documentation. Prioritize updates based on potential impact: new properties that enable additional rich results, deprecated properties requiring replacement, and emerging schema types relevant to SaaS offerings ⁶.

For implementation, create a schema governance process with designated ownership (typically SEO or product marketing team). Schedule quarterly reviews where the team evaluates new Schema.org releases (typically 2-3 per year), assesses applicability to their SaaS products, and prioritizes implementation. When Google announces new rich result types (like AI Overview eligibility criteria), rapidly test implementation on high-value pages.

A SaaS company established a quarterly schema review process that identified the new “SoftwareSourceCode” schema type relevant for their developer-focused product. They implemented it within two weeks, gaining visibility in code-related searches. They also discovered that Google had updated “aggregateRating” requirements to mandate “reviewCount” (previously optional), which they added to maintain rich result eligibility. This proactive approach helped them maintain 95%+ rich result coverage while competitors experienced drops due to outdated implementations ¹⁶.

See Also

• Structured Data Testing and Validation Tools
• AI Search Optimization Strategies for SaaS
• Knowledge Graph Development for Brand Entities
• Voice Search Optimization for SaaS Products

References

1. HashMeta. (2024). JSON-LD. https://hashmeta.com/seo-glossary/json-ld/
2. JSON-LD. (2024). JSON for Linking Data. https://json-ld.org
3. Sitechecker. (2024). What is JSON-LD. https://sitechecker.pro/what-is-json-ld/
4. Jasmine Directory. (2024). Structured Data Standards JSON-LD for Directory Publishers. https://www.jasminedirectory.com/blog/structured-data-standards-json-ld-for-directory-publishers/
5. Salt Agency. (2024). Schema for SaaS Companies. https://salt.agency/blog/schema-for-saas-companies-salt-agency/
6. Seobility. (2024). JSON-LD. https://www.seobility.net/en/wiki/JSON-LD
7. Team4 Agency. (2024). Schema.org JSON-LD Embed in Webflow. https://www.team4.agency/glossary/schema-org-json-ld-embed-in-webflow
8. CloudBees. (2024). JSON-LD Building Meaningful Data APIs. https://www.cloudbees.com/blog/json-ld-building-meaningful-data-apis
9. Fluree. (2024). What is JSON-LD. https://flur.ee/fluree-blog/what-is-json-ld/
10. Envigo. (2024). Comparison Various Schemas and Benefits JSON-LD Over These Old Formats. https://www.envigo.co.in/blog/comparison-various-schemas-and-benefits-json-ld-over-these-old-formats