Schema markup implementation guide: master structured data for local SEO & rich results

Picture a Google search result that shows star ratings, business hours, pricing, and FAQ answers before anyone clicks. That’s a rich result, and it captures attention in a way standard blue links simply can’t.

Milestone Research has found that pages displaying rich results can see click-through rate improvements between 20% and 30% over standard listings. For local businesses especially, schema markup (the code behind those rich results) directly feeds the data Google uses to populate local packs, maps, and knowledge panels.

The problem? Schema still intimidates most site owners. The vocabulary is confusing, the formats are technical, and the Schema.org documentation reads more like a PhD thesis than a practical how-to. (I’ve been there. Early on, I’d mix up “structured data” with “schema” with “rich snippets” and wonder why nothing I implemented actually showed up in search.)

This guide fixes that. You’ll learn what schema markup actually is, why Google cares about it, and how to implement the most impactful types using JSON-LD with copy-paste code examples. We cover LocalBusiness, Product, FAQ, Article, and Event schema, followed by practical methods for deploying markup to any website, validating it for errors, and measuring whether it’s driving real results.

No prior coding experience needed. Just a willingness to add a few script tags.

What is schema markup and why it’s critical for modern SEO?

Schema markup is a vocabulary of tags you add to your HTML to tell search engines what your content means, not just what it says. Google Search Central defines structured data as “a standardized format for providing information about a page and classifying the page content.” In plain terms, it’s the difference between Google seeing the text “4.8” on your page and Google understanding that “4.8” is a customer rating out of 5 stars.

The vocabulary itself comes from Schema.org, a collaborative project founded by Google, Bing, Yahoo, and Yandex to create a shared language for structured data on the web. Think of Schema.org as a dictionary that all major search engines agree to read.

Demystifying the terminology: Schema.org, structured data & rich snippets

Three terms get tangled constantly, and the confusion stops people from starting.

Schema.org is the vocabulary. It defines hundreds of “types” (like LocalBusiness, Product, Event) and their properties (like name, address, price). It’s the dictionary.

Structured data is the format. It’s how you write the vocabulary into your website’s code. The three formats are JSON-LD, Microdata, and RDFa. It’s the grammar.

Rich results (sometimes called “rich snippets”) are the output. They’re the enhanced search listings that Google generates when it reads and validates your structured data. Star ratings on a recipe, FAQ dropdowns below a listing, event dates in search: those are all rich results.

An analogy that helps: Schema.org gives you the words, structured data is the sentence you write, and rich results are what Google decides to print on the page.

Google Search Central maintains a gallery of all supported rich result types, and it’s worth bookmarking. Not every Schema.org type triggers a rich result, so checking Google’s gallery before implementation saves you from marking up data that won’t produce any visible benefit.

The SEO superpower: how schema boosts visibility & CTR

Does schema markup directly impact rankings? Google has said it’s not a direct ranking signal. But calling it “just a visual enhancement” misses the point entirely.

Rich results take up more visual real estate on the search results page. A listing with star ratings, prices, and availability information draws the eye in a way a plain blue link can’t compete with. Industry research from Milestone Inc. suggests click-through rate improvements of 20-30% for pages displaying rich results compared to standard listings.

The indirect ranking benefits compound from there. Higher CTR signals to Google that your result is satisfying user intent. More clicks mean more engagement. More engagement, over time, can influence your position.

Schema also feeds Google’s Knowledge Graph, the massive database of entities and relationships that powers knowledge panels, “People also ask” boxes, and entity-based search features. When you implement Organization or LocalBusiness schema, you’re directly telling Google how your business entity connects to locations, reviews, products, and services.

For local businesses, the impact is even more direct. BrightLocal’s research consistently shows that the vast majority of consumers use Google to evaluate local businesses. LocalBusiness schema feeds the exact data points (hours, phone number, address, reviews) that appear in local pack results and Google Maps listings.

Schema’s role in the AI search revolution: Google AI Overviews & beyond

AI-powered search is changing how answers get assembled. Google AI Overviews pull information from multiple sources and synthesize it into conversational responses, and structured data gives Google’s AI systems a clear, unambiguous signal about what your content contains.

Think about it from the AI’s perspective. When an AI model needs to answer “What are the best Italian restaurants near me that are open on Sundays?”, it needs structured fields: cuisine type, location, opening hours. Pages with LocalBusiness schema containing those exact properties are far easier for an AI to parse than pages where that information is buried in paragraph text.

Google has stated publicly that structured data helps its systems “understand the content of the page” for search features. This extends naturally to AI-generated results.

Voice search follows the same logic. When someone asks their phone “What time does [business] close?”, the answer comes from structured data. Without schema, your business hours exist only as text on your website. With schema, they exist as queryable data points that voice assistants can pull directly.

If you want a deeper look at how AI search is reshaping SEO strategy, I wrote about this extensively in my guide on advanced SEO strategies for the generative search era.

Mastering JSON-LD: Google’s preferred structured data format

Three formats exist for adding structured data to websites: JSON-LD, Microdata, and RDFa. Google recommends JSON-LD as its preferred format, and for good reason.

Why JSON-LD is the go-to for SEO (and how it works)

JSON-LD stands for JavaScript Object Notation for Linked Data. Unlike Microdata and RDFa (which require you to weave schema attributes directly into your HTML elements), JSON-LD lives in a standalone <script> tag. Your page’s markup stays clean, and your structured data stays separate.

This separation matters for three practical reasons:

1. Maintenance. You can update your structured data without touching your page templates. If your business hours change, you edit the JSON-LD block, not a dozen HTML attributes scattered across your page.

2. Implementation. JSON-LD can be injected via Google Tag Manager, CMS plugins, or a simple copy-paste into your page’s code. You don’t need to understand your site’s HTML structure to add it.

3. Readability. For anyone auditing or debugging, a single JSON-LD block is far easier to scan than Microdata attributes sprinkled throughout your HTML.

Here’s the anatomy of a basic JSON-LD block:

{
  "@context": "https://schema.org",
  "@type": "WebPage",
  "name": "About Our Company",
  "description": "Learn about our team, mission, and history.",
  "url": "https://www.example.com/about"
}

Wrap this in a <script type="application/ld+json"> tag and place it in your page’s HTML. Every JSON-LD block starts with @context (which tells search engines you’re using Schema.org vocabulary) and @type (which specifies what kind of thing you’re describing). After that, you fill in properties relevant to that type.

Placing your JSON-LD: head vs. body

Google’s documentation confirms that JSON-LD can be placed in either the <head> or <body> of your HTML document. Both locations work.

The <head> is the convention most SEO professionals follow, since it keeps structured data grouped with other metadata. But if your CMS or deployment method only allows body injection (common with Google Tag Manager or page builders), that works too.

One rule: don’t dynamically generate JSON-LD using client-side JavaScript in a way that requires rendering. Google’s crawler does render JavaScript, but it adds complexity and potential points of failure. Static JSON-LD or server-side generated JSON-LD is always the safer choice.

Key schema types for rich results & local SEO: step-by-step implementation

This is where we get practical. Each schema type below includes a full JSON-LD example you can adapt for your own site. For each one, wrap the JSON in a <script type="application/ld+json"> tag before adding it to your page.

LocalBusiness schema: your strongest local SEO signal

LocalBusiness schema tells Google exactly what your business is, where it’s located, and how customers can reach you. For local SEO, this is the highest-impact schema type you can implement.

Here’s a complete JSON-LD example for a local restaurant:

{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "name": "Mamma Rosa's Italian Kitchen",
  "image": "https://www.mammarosas.com/images/storefront.jpg",
  "url": "https://www.mammarosas.com",
  "telephone": "+1-555-123-4567",
  "priceRange": "$$",
  "servesCuisine": "Italian",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main Street",
    "addressLocality": "Austin",
    "addressRegion": "TX",
    "postalCode": "78701",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 30.2672,
    "longitude": -97.7431
  },
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "11:00",
      "closes": "22:00"
    },
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Saturday", "Sunday"],
      "opens": "10:00",
      "closes": "23:00"
    }
  ],
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "312"
  }
}

A few details that matter: the @type should be as specific as possible. “Restaurant” is better than “LocalBusiness” because it gives Google more precise information. Schema.org lists dozens of LocalBusiness subtypes, including Dentist, AutoRepair, BeautySalon, LegalService, and more. Use the one that fits your business.

The geo property with latitude and longitude coordinates is often overlooked, but it helps Google place your business accurately on Maps, especially when your address alone might be ambiguous.

Pro tip: Your schema data must match what appears on the page. If your schema says you close at 10 PM but your website says 9 PM, Google may flag the inconsistency and suppress your rich results. Keep both in sync.

Advanced local: multi-location & service area businesses

Businesses with multiple locations should implement separate LocalBusiness schema for each location, not a single block listing all addresses. Each location gets its own JSON-LD block with its specific address, hours, and phone number.

For service-area businesses (plumbers, landscapers, delivery services) that don’t have a physical storefront customers visit, use the areaServed property instead of (or in addition to) address:

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "QuickFix Plumbing",
  "url": "https://www.quickfixplumbing.com",
  "telephone": "+1-555-987-6543",
  "areaServed": [
    {
      "@type": "City",
      "name": "Austin"
    },
    {
      "@type": "City",
      "name": "Round Rock"
    },
    {
      "@type": "City",
      "name": "Cedar Park"
    }
  ]
}

For franchise operations, the pattern stays the same: one JSON-LD block per location, each with a unique URL pointing to that location’s dedicated page. Avoid putting all locations on a single page with a single schema block. Google wants one entity per block.

Product schema: boost e-commerce visibility & sales

Product schema enables those rich search results showing price, availability, and star ratings directly in Google. For e-commerce sites, this is non-negotiable.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Ergonomic Standing Desk Pro",
  "image": "https://www.example.com/images/standing-desk-pro.jpg",
  "description": "Height-adjustable standing desk with programmable memory settings and cable management.",
  "brand": {
    "@type": "Brand",
    "name": "DeskCraft"
  },
  "sku": "DC-ESDP-2026",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "bestRating": "5",
    "reviewCount": "1243"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.com/products/standing-desk-pro",
    "priceCurrency": "USD",
    "price": "549.00",
    "availability": "https://schema.org/InStock",
    "seller": {
      "@type": "Organization",
      "name": "DeskCraft Official Store"
    }
  }
}

The offers property is where most of the rich result value lives. Price, currency, and availability directly populate the product panels Google shows in search. The aggregateRating drives the star display.

Google’s Product structured data documentation lists all supported properties and which ones are required versus recommended. At minimum, you need name and either review, aggregateRating, or offers to be eligible for rich results.

Pro tip: Keep availability updated. Nothing erodes trust faster than a rich result showing “In Stock” when the product is actually sold out. If you run a large catalog, automate this field through your CMS or inventory system.

FAQPage schema: answering user questions directly on SERPs

FAQPage schema creates expandable question-and-answer dropdowns directly in search results. Google changed the rules here, though. In 2023, Google restricted FAQ rich results primarily to well-known, authoritative government and health websites for many queries. For other sites, FAQ schema may still produce rich results in certain contexts, but the visibility is more limited than before.

Should you skip FAQ schema entirely? No. It still helps search engines understand the Q&A structure of your content, and it’s simple to implement:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does shipping take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Standard shipping takes 5-7 business days. Express shipping delivers within 2-3 business days."
      }
    },
    {
      "@type": "Question",
      "name": "What is your return policy?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "We accept returns within 30 days of purchase. Items must be in original condition with tags attached."
      }
    }
  ]
}

Each question-answer pair lives inside the mainEntity array. The content in your schema must match the visible content on your page. Google will suppress FAQ rich results for pages where the schema answers don’t appear in the on-page content.

Article schema: enhancing blog posts & news content

Article schema helps Google understand your content’s metadata: who wrote it, when it was published, when it was updated. This is especially valuable for E-E-A-T signals, since it connects your content to a specific author and publisher entity.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to choose the right running shoes",
  "image": "https://www.example.com/images/running-shoes-guide.jpg",
  "author": {
    "@type": "Person",
    "name": "Sarah Chen",
    "url": "https://www.example.com/authors/sarah-chen"
  },
  "publisher": {
    "@type": "Organization",
    "name": "FitGear Magazine",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.example.com/logo.png"
    }
  },
  "datePublished": "2026-03-15",
  "dateModified": "2026-03-28",
  "description": "A practical guide to selecting running shoes based on your gait, terrain, and training goals."
}

The author property is becoming increasingly important as Google invests in E-E-A-T evaluation. Linking the author to a dedicated author page (with their own Person schema) creates a stronger signal of expertise and authorship. Google’s Article structured data documentation provides the full property list and eligibility requirements.

Keep dateModified current. When you update an article, update this field. Google uses it to assess content freshness.

Event schema: promoting occurrences in search

Event schema produces rich results showing event name, date, location, and ticket information directly in search. This works for both physical and virtual events.

{
  "@context": "https://schema.org",
  "@type": "Event",
  "name": "Local SEO workshop: schema markup for small businesses",
  "startDate": "2026-05-15T09:00:00-05:00",
  "endDate": "2026-05-15T12:00:00-05:00",
  "eventAttendanceMode": "https://schema.org/OnlineEventAttendanceMode",
  "eventStatus": "https://schema.org/EventScheduled",
  "location": {
    "@type": "VirtualLocation",
    "url": "https://www.example.com/events/schema-workshop"
  },
  "description": "A 3-hour hands-on workshop covering schema implementation for local businesses.",
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.com/events/schema-workshop/register",
    "price": "49.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "organizer": {
    "@type": "Organization",
    "name": "LocalSEO Academy",
    "url": "https://www.example.com"
  }
}

For physical events, replace VirtualLocation with a Place type containing the venue’s address. Google’s Event structured data guide details all supported properties including performer for concerts and shows.

Two things that trip people up: dates must include timezone information (the -05:00 part), and event status (EventScheduled, EventPostponed, EventCancelled) matters for accuracy during rescheduling.

Practical implementation: adding schema to your website (low-code strategies)

Knowing the schema types is step one. Getting them onto your website is step two. Here are four methods, ordered from simplest to most technical.

Option 1: schema markup generators (the easiest way)

If you’ve never touched structured data before, start here. Schema generators give you a form-based interface: fill in your business name, address, hours, and other details, and the tool produces the JSON-LD code for you.

Two reliable options:

• Google’s Structured Data Markup Helper walks you through tagging elements on a page and generates code. It’s free and directly from Google.
• Merkle’s Schema Markup Generator lets you pick a schema type and fill in properties through a clean interface. It supports more types than Google’s tool and produces ready-to-paste JSON-LD.

The workflow is simple: pick your schema type, fill in the fields, copy the generated JSON-LD, and paste it into your website’s HTML.

Option 2: WordPress plugins (for CMS users)

If you run WordPress, several plugins handle schema generation automatically based on your page content and settings:

• Rank Math includes a schema module that auto-generates common types (Article, Product, LocalBusiness) and lets you add custom schema per page.
• Yoast SEO generates Organization and Article schema by default, with more types available in the premium version.
• Schema Pro is a dedicated schema plugin with broader type coverage and conditional logic for different page templates.

All three integrate with your existing WordPress content and require minimal configuration. For most small business sites, Rank Math or Yoast handles schema without you needing to write a line of code.

Option 3: manual JSON-LD insertion (for precision & control)

For those comfortable editing HTML, manual insertion gives you full control. The process depends on your platform:

Custom websites. Add the <script type="application/ld+json"> block directly to your page template’s <head> section.

Shopify. Go to Online Store, then Themes, then Edit Code, and add JSON-LD to your theme.liquid file or individual template files. Shopify includes basic Product schema by default, but you’ll want to extend it with additional properties.

Squarespace. Use the Code Injection feature (Settings, then Advanced, then Code Injection) to add JSON-LD to the header. For page-specific schema, use the per-page code injection option.

Manual insertion works best when you need schema that’s more specific or customized than what generators or plugins produce.

Option 4: Google Tag Manager (dynamic schema deployment)

Google Tag Manager (GTM) can inject JSON-LD dynamically without changing your site’s source code. This is useful for larger sites where direct code access is limited or where you want to deploy schema across many pages from a single interface.

The approach: create a Custom HTML tag in GTM containing your JSON-LD script, set up triggers to fire it on specific pages, and publish. GTM handles the injection.

One caveat: while Google can read GTM-injected structured data, the rendering dependency adds a layer of complexity. If your GTM container loads slowly or has errors, your schema might not appear when Googlebot crawls. For high-priority schema (like LocalBusiness or Product), direct insertion is more reliable.

Validating & troubleshooting your schema markup

Deploying schema without testing it is like shipping code without QA. (I’ve written at length about why that’s a bad idea in my SEO QA checklist guide.) Validation catches errors before they prevent your rich results from appearing.

Step-by-step: using Google’s Rich Results Test

Google’s Rich Results Test is the primary validation tool. Here’s how to use it:

1. Go to the tool and enter your page URL (or paste your code directly).
2. The tool renders your page and extracts all detected structured data.
3. Results show whether your schema is “eligible” for rich results, along with any warnings or errors.

“Eligible” means your markup is valid and could trigger rich results. It doesn’t guarantee Google will show them. That depends on the query, competition, and Google’s own quality assessments.

Warnings are suggestions (like missing recommended properties). Errors are blockers (like missing required properties or invalid data types). Fix errors first. Address warnings when you can.

Pro tip: Test with both a URL and with code. The URL test shows what Google sees on the live page, including any dynamically generated schema. The code test shows whether your raw JSON-LD is valid before deployment.

Understanding and resolving common schema errors

Five errors account for most schema implementation problems:

1. Missing required properties. Every schema type has properties Google marks as required. For Product, you need name and at least one of review, aggregateRating, or offers. Check Google’s documentation for each type’s requirements.

2. Incorrect data types. Price values must be numbers, not formatted strings. "price": "549.00" works. "price": "$549" doesn’t. Dates must follow ISO 8601 format (YYYY-MM-DD).

3. Schema-content mismatch. Google compares your structured data against visible page content. If your schema says “4.8 stars” but your page shows “4.5 stars,” expect suppressed rich results.

4. Conflicting schema blocks. Multiple JSON-LD blocks that describe the same entity with different data confuse parsers. One entity, one block.

5. Marking up hidden content. Adding schema for content that users can’t see (hidden divs, display: none elements) violates Google’s structured data policies and can result in manual actions.

The Schema Markup Validator: when to use it

The Schema Markup Validator (maintained by Schema.org) validates your structured data against the full Schema.org vocabulary, not just the subset Google supports for rich results.

Use this tool when you’re implementing schema types that don’t appear in Google’s Rich Results Test gallery, when you want to verify your markup is syntactically correct regardless of Google support, or when you’re debugging complex nested schema with multiple types.

It complements the Rich Results Test rather than replacing it. Use both: the Schema Markup Validator for correctness, the Rich Results Test for Google eligibility.

Monitoring performance & maximizing your schema ROI

Implementation is the start. Measuring impact tells you whether it’s actually working and where to invest further.

Tracking rich results in Google Search Console (GSC)

Google Search Console provides the most direct view of your schema performance. Go to the “Enhancements” section in the left sidebar, where GSC reports the status of each detected rich result type on your site.

For each type (FAQs, Products, Local Businesses), you’ll see valid items (pages with correct schema eligible for rich results), items with warnings (valid but with recommended improvements), and errors (pages where schema issues prevent rich result eligibility).

Use the Performance report with the “Search Appearance” filter to see impressions and clicks specifically for rich results. This shows you whether your schema is generating actual traffic, not just appearing valid in the backend.

Beyond GSC: advanced performance metrics & ROI

GSC tells you what’s happening. To understand the business impact, you need to track a few things alongside it.

Organic CTR changes. Compare your CTR before and after schema implementation for the same pages. A meaningful increase (even 5-10%) on high-traffic pages translates to significant additional clicks. If you’re working within a broader SEO roadmap, tie schema implementation to your overall organic growth targets.

Local pack visibility. For local businesses, tools like BrightLocal track your appearance frequency in local pack results over time. Schema implementation should correlate with improved visibility here.

Conversion attribution. If your schema-enhanced pages (product pages with review stars, local pages with hours and phone numbers) see higher conversion rates post-implementation, that’s direct ROI. Compare conversion rates for pages with schema versus similar pages without it.

I’ve seen this play out at scale. At Hotels.com, we rolled out structured data across thousands of lodging landing pages while simultaneously addressing a 20% traffic decline on our content app after a CMS migration. The schema implementation required careful prioritization (we allocated two-thirds of our senior technical PM’s capacity to it), but the payoff justified the focus: rich snippet eligibility appeared across thousands of pages, and the CTR and conversion improvements that followed gave us a clear before-and-after story to present to leadership. That kind of measurable evidence is what turns schema from a “nice to have” into a funded initiative.

Maintaining & updating your schema strategy

Schema markup is not a set-and-forget implementation. Three things trigger updates:

Business changes. New hours, new locations, new products, price changes. Any data in your schema that falls out of sync with your page content can suppress rich results or show incorrect information to customers.

Google guideline updates. Google periodically changes which schema types trigger rich results and what properties are required. The 2023 FAQ schema restriction is a textbook example. Follow Google Search Central’s blog for announcements.

Schema.org vocabulary updates. Schema.org releases new types and properties regularly. New opportunities appear (like the expanding support for SpecialAnnouncement during COVID) and staying current means you can adopt them early. If you’re managing crawl budget effectively, you’ll also want to make sure your schema changes don’t inadvertently affect how search engines prioritize crawling your pages.

Set a quarterly review cadence. Check your GSC Enhancements reports for new errors, verify that your schema data matches current page content, and review Google’s latest structured data documentation for changes.

Start implementing schema markup today. Pick one type that matches your business (LocalBusiness if you serve a local area, Product if you sell online, Article if you publish content) and deploy it on your highest-traffic page first. Test it with the Rich Results Test, fix any errors, and monitor the results in Search Console. One page, one schema type, one test. That’s all it takes to see the impact for yourself.

References

1. Google Search Central. “Introduction to structured data.” https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data
2. Schema.org. “About Schema.org.” https://schema.org/docs/about.html
3. Google Search Central. “Product structured data.” https://developers.google.com/search/docs/appearance/structured-data/product
4. Google Search Central. “FAQ structured data.” https://developers.google.com/search/docs/appearance/structured-data/faqpage
5. Google Search Central. “Article structured data.” https://developers.google.com/search/docs/appearance/structured-data/article
6. Google Search Central. “Event structured data.” https://developers.google.com/search/docs/appearance/structured-data/event
7. Google Search Central. “Local business structured data.” https://developers.google.com/search/docs/appearance/structured-data/local-business
8. Google Search Central. “Search gallery.” https://developers.google.com/search/docs/appearance/structured-data/search-gallery
9. Google Search Central. “Structured data general guidelines.” https://developers.google.com/search/docs/appearance/structured-data/sd-policies
10. BrightLocal. “Local consumer review survey.” https://www.brightlocal.com/research/local-consumer-review-survey/
11. Milestone Inc. “Schema research: schemas positively impact multiple aspects of visibility and organic performance.” https://go.milestoneinternet.com/schema-research-paper
12. Schema.org. “LocalBusiness.” https://schema.org/LocalBusiness
13. Schema Markup Validator. https://validator.schema.org/
14. Google Rich Results Test. https://search.google.com/test/rich-results
15. Google Search Console. https://search.google.com/search-console/about