Google website verification: complete practical guide to all methods

SEO admin 19 December 2024 Reading time : 35 minutes

Put us to the test!

Analyze your site

Select the database

It is not just a formality or a matter of access: the process of verifying the site in Google Search Console is the first step to start exploiting the potential of the platform, the one that allows us to prove to Google that we are in control of the site and have access to its valuable data, including those related to performance in Search. The process may seem straightforward, but without the right guidance, you run the risk of making mistakes that unnecessarily complicate the work; moreover, with as many as seven official methods available, each with specific features and technical requirements, it is crucial to choose the one best suited to your needs and configurations. It doesn’t matter whether your site is hosted on WordPress, managed through a provider such as Wix, or uses a custom domain: understanding how to proceed is essential to avoid obstacles and start reaping the benefits of the data provided by Search Console. Here, then, is a comprehensive guide to how to complete the Google verification process smoothly, through all the options and steps needed to gain access to Search Console and the data to improve your site’s visibility and organic performance.

What is Google website verification

Google site verification, or more correctly site verification in Google Search Console, is the process of proving to Google that we have control and legitimate ownership of a specific domain or URL. This is a crucial step because it enables full access to the sensitive and strategic data collected by Search Console, which we know is very important for effectively managing site performance in Search.

The full power of data

Integrate GSC analytics with SEOZoom statistics to monitor SERP movement and get ahead of your competitors

Find out more

When Google asks to verify a site, it is essentially requesting proof that there is a direct link between the domain administrator and the site’s configuration. Only after this verification do we gain access to vital data on indexing, organic visibility and technical issues that could negatively affect ranking. Moreover, verifying the property allows for active intervention: for example, we can request indexing of new pages, analyze user behavior, or take corrective measures to optimize every aspect of online performance.

Google site verification: what it is for and why it is essential

Property verification on Google Search Console is an essential procedure for any website owner who wishes to effectively manage their online presence.

Through this process, actual site owners in Search Console can gain access to sensitive Google Search data about the domain entered, which can affect its presence and behavior in Search and other Google services. In addition, a verified owner may grant access to other people, who may view or manage data from those sites in Search Console.

Google requires this procedure to ensure that only legitimate owners or authorized managers can view strategic information and manage site behavior interventions in Search results. This protection mechanism is essential to prevent unauthorized access and ensure maximum security of the data contained in the property.

The ability to complete the verification using different modes (such as DNS records, HTML tags, HTML files, Google Analytics or Google Tag Manager) makes this operation flexible and adaptable to any technical need or site configuration.

Why verify site ownership

Verifying a site’s ownership is therefore key to unlocking strategic data about its performance in Google Search and taking full control of it at the operational level. Once this procedure is completed, we finally access the heart of the functionality offered by Google Search Console: advanced reports, monitoring tools and intervention tools that directly affect the SEO of the site.

On a practical level, the audit gives us access to sensitive information about the organic performance of the site, such as the volume of traffic generated, the most effective search queries, and user behavior. We can find out which URLs are indexed correctly, report any anomalies, and request the indexing of new pages, effectively speeding up the process by which the site is scanned and updated by Google’s crawlers.

In addition, the audit is necessary to use other strategic functions, such as sitemap management, crawlability error analysis, and index coverage troubleshooting. Without this verification test, we lose access to critical tools for optimizing site ranking and maximizing site visibility.

An important aspect related to verification concerns data security. Only verified owners can consult the information in Search Console, thus avoiding risks of accidental sharing or unauthorized access. The availability of alternative methods also makes it possible to ensure continuity of access if the original method is no longer usable (e.g., following a change in a site or domain).

What happens if you do not verify the site

Failure to complete verification is tantamount to giving up effective control over the site’s online presence and being limited only to monitoring the basic interactions that Google provides to the unverified. Without validated ownership, we lose the right to access the detailed data generated by the site in Google Search, effectively excluding us from the most valuable information offered by the platform.

This means that we will have no way of knowing:

How Google interprets the pages on our site. Any indexing problems or duplicate content could remain ignored, which would directly affect our ranking.
Which queries bring organic traffic to the site. Without data on actual keywords and queries, optimizing existing content or creating new content becomes a process based on intuition rather than analysis.
The overall technical state of our platform. Crawability errors, broken links or manual actions applied by Google may go unnoticed, slowing the growth of the online project.

Failure to have access to Search Console also results in the inability to request page indexing or upload a sitemap, leaving the site to be scanned by Google’s crawlers without any control over the process and timing. This limitation can drastically slow down the updating of indexes and, consequently, the appearance of new content in search results.

Finally, without verification, we will not even be able to diagnose and resolve critical technical errors, such as DNS problems, misconfigured redirects or content wrongly blocked by robots.txt. Thus, those who leave site verification unresolved give up not only the chance to improve their visibility, but also the chance to protect their ranking and correct any technical obstacles in a timely manner.

How to choose the right method for site verification in Search Console

Beyond its value, however, at the end of the day verifying the site is still “a simple step that tests the ability to update and make small, unseen changes to the site,” and takes “only a few minutes,” as Daniel Waisberg, Google’s Search Advocate, explained in an episode of the Google Search Console Training series on YouTube.

The real critical issue is the choice of verification method in Google Search Console, because each system offers specific peculiarities that may fit differently to our technical configurations and the needs of our online project.

There are currently seven different verification methods available in Search Console, each developed to meet the different characteristics of websites, hosting platforms, and levels of technical control available. Some options, such as DNS record or HTML file upload, require direct domain or server control, while others, such as using Google Tag Manager or Google Analytics, take advantage of tools already installed on the site to simplify the process.

Knowing which method to choose means not only successfully completing the task, but also providing flexibility to handle future technical changes to the site, distributed access among multiple contributors, or dynamic configurations. Starting with a distinction between domain and URL prefix properties , we can already outline the main usage scenarios and technical implications of the two types of verification.

Domain and URL prefix: comparing the two properties

Regardless of the method we choose to use, the procedure for property verification in Google Search Console always begins identically: after saying goodbye to the preferred domain setting, we now in fact have to log in to Google Search Console and click on “add property” or choose an unverified property from the selection bar; or, if it is the first time ever logging in with a property that has never been verified, the GSC wizard guides us through the procedure.

The second step is to indicate the type of property to be verified from the two options available-Domain (domain) and URL prefix (URL prefix)-which allow all URLs on the site and subdomains to be verified or only addresses corresponding to those added, respectively. Waisberg recommends creating at least one domain property to represent the site because it provides the most overall information for project management, while URL prefix would be used only to monitor individual sections of the site or to limit access to all information to any external contributors.

When to choose domain ownership

Domain ownership is the most comprehensive mode and allows us to check all variants of our domain, including protocol combinations (HTTP and HTTPS) and subdomains (e.g., www, m.). This solution is ideal if we want to have a comprehensive view of site activity and ensure continuity of tracking even when configuration changes are implemented, such as the introduction of an SSL certificate or subdomains. However, the only supported verification method for this property is to add a DNS record via the domain provider, a process that may be more complex for those unfamiliar with DNS management.

To recap, the domain property does the trick:

When we want a global view of the site, without worrying about its technical variations.
If we plan to work with subdomains or HTTPS versions not yet activated.
If we can access the DNS management panel and are confident about adding records.

When to choose URL prefix

In contrast, URL prefix focuses on a single specific URL with all its resources linked. For example, a property“https://www.example.com ” will monitor only the activity of that particular configuration, excluding any variants such as“http://example.com ” or “https://blog.example.com ”. This approach proves useful when we want to monitor only one part of the site, such as a subdomain or a dedicated folder, and is compatible with a wide range of verification methods (including HTML file uploads, HTML tags, and built-in tools such as Google Analytics). However, it requires more care, as any changes to the URL structure could invalidate the verification.

And so, we choose URL prefix:

If we are only interested in monitoring a specific section of the site (ex: a subdomain, a dedicated folder or a particular URL).
When it is easier to use alternative methods of verification, such as an HTML meta tag or the already installed Google Analytics code.
If we want to restrict access to the dataset and configurations, e.g., for an external contributor or a third party.

Google website verification, the features of different methods

As mentioned, Google Search Console offers seven main methods for verifying a site, each designed to suit different technical needs and platforms and each distinguished by requirements, benefits and possible limitations: the choice will depend on the technical skills available, the configuration of the site and the tools already in use.

Uploading an HTML file is one of the simplest procedures: Google provides a unique file to download and upload to the site’s root directory. This method is useful when we can access the server or use a file manager, and verification is immediate once the file is successfully published. However, it requires direct access to the server, which may not be available in all hosting configurations.

Inserting an HTML tag, on the other hand, allows the property to be verified by adding a specific metatag in the <head> section of the source code of the site’s home page. It is an ideal choice for those using platforms that allow editing of HTML files, such as WordPress, and offers a flexible option when combined with dedicated plugins. The limitation of this solution is that it requires direct access to the site source code.

Linking with Google Analytics represents an opportunity for those who have already installed tracking code on their site and have editing rights in the linked account. In this case, verification takes advantage of the existing snippet, avoiding manual code or server interventions. However, it is essential to have up-to-date and properly configured Analytics settings, as old snippets or incomplete configurations can cause errors.

Those using Google Tag Manager can verify their site using the container snippet already in place. This option is particularly useful for those operating in dynamic environments and benefiting from Tag Manager’s automations, but again it is necessary to confirm that the snippet is configured in the correct location to avoid complications.

The DNS record, again, is a powerful solution and is the only accepted method for verifying “domain” type properties. This approach allows the entire domain with all its variants (http/https, www/not www, subdomains) to be verified by configuring a TXT or CNAME record at the DNS provider. It is particularly useful for those who want a global view of the site, but may be technical and complex for those unfamiliar with DNS management.

Finally, for those using Google platforms such as Sites and Blogger, it is possible to take advantage of the native settings of these solutions for an almost automatic verification process. This method combines simplicity and immediacy, as the integration between Google products simplifies the management of verification tokens.

Google site verification methods: all the steps in detail

Before we set off on a detailed discovery of the seven different systems for doing site verification there are still a few small technical aspects to consider.

First, the verification remains valid as long as Search Console is able to confirm the presence and validity of the verification token. Also, Google uses the Google Site Verifier user agent to periodically run the site verification and check if the verification token is still present and valid, and we will receive a notification if the verification can no longer be confirmed. If the problem is not resolved, Google will cause our property-related permissions to expire after a specified grace period; if all verified owners lose access to a property, all users will consequently lose access to the Search Console property.

Verification by DNS records

Verification by DNS records is the preferred method when we need to configure a domain type property , but it can also be used to verify URL properties. This option works with the addition of a DNS record in the domain name provider, was implemented in 2019, and allows us to monitor all variants of our domain, including different protocols (http/https) and subdomains (e.g.: www, m.), giving a complete and comprehensive view of the data collected by Search Console. However, it is one of the more technical methods, as it requires access and expertise in managing our provider’s DNS panel.

To proceed with the process, we must first enter the domain name in the form (without the protocol or slashes), and then choose one of two options in the next box: select the provider of your domain name, if present in the list, or add a new TXT record.

The first case is simpler and faster: you land on the provider’s login page, from which to log in and authorize communication with the Google Search Console, to which we will then be redirected. Verification usually takes a few hours, a few days at most, and if necessary we can repeat the process if we are concerned that it did not work, keeping in mind that sometimes DNS record changes can be slow.

If the name of the provider is not included in the list, you must follow the instructions written in the Help Center to complete the procedure, thus entering the DNS text record and copying the Google token that appears on the screen: instructions are given for many providers, which often have different systems, but it should not be difficult to complete the operation.

It is important then to remember not to remove the DNS record from the provider, even after successful verification, to keep the property always verified.

When to choose verification with DNS records

DNS record is the only option available for those who wish to verify a domain property. It is especially recommended if we want to collect data from all configurations and subdomains of our site in a single property, such as for complex projects or platforms that require centralized control.

Practical guide to verification using DNS records

Here are the steps to complete verification using a TXT (or CNAME) record through our DNS provider:

We log into Google Search Console. We enter the platform and add a new property. We choose the Domain option in the configuration window.

We identify the DNS provider

We consult the documentation or support pages to identify the domain name provider (e.g. Cloudflare, GoDaddy, Aruba).
If we do not know the provider used for the domain, you can use tools such as “Whois Lookup” or other online DNS lookup options to accurately identify it.

We obtain the DNS verification record. Google Search Console generates a unique record for verification of ownership. This will be provided in the form of a TXT record or, in some cases, a CNAME record.

For TXT records, the string will have a format similar to this: google-site-verification=xxxxxxxxxxxxxxxxxxxxxxxxx.
For CNAME records, two values will be provided: one for the “name/host” field and one for the “target/destination” field.

Let’s add the records in the domain DNS. We access the DNS provider’s control panel, going to the DNS management or DNS settings section. Let’s add a new record:

For TXT:

Type: TXT.

Name/Host: we leave blank or use @ (depending on the provider).

Value: we paste the string provided by Google.

For CNAME:

Type: CNAME.

Name/Host: we use the value provided by Google.

Target/Destination: we enter the target value generated by Google.

We save the changes to the DNS provider. After adding the values corresponding to TXT or CNAME, we save the changes. If the provider requires it, we confirm the changes by clicking “Apply” or “Publish.”
We check the propagation of the DNS record. The DNS propagation process can take from a few minutes to up to 48 hours, depending on the provider. We can use tools such as DNS Checker or Google Admin Tools to check that the record has been applied correctly and is publicly visible.
We complete the check in Google Search Console. We return to the configuration window in Search Console and click on Verify. If the DNS record has been propagated correctly, the property will be verified immediately.

Common problems during DNS configuration.

Despite the accuracy of the process, frequent errors related to configuration and propagation can occur. The most common are:

DNS record not found: it may not yet be fully propagated on the global network. In this case, it is best to wait a few hours and check again.
Incorrect value: the added record may not exactly match the one provided by Google. Let’s check that the copied content is identical.
Wrongly configured fields: make sure that the name/host is empty or set with @ and that the final value is pasted in the field required by the provider.

Tips for keeping the property confirmed

Do not remove the TXT or CNAME record from DNS after verification: the token is critical to maintaining the validity of the property and Google requires periodic verifications.
Monitor any changes to DNS for events such as domain transfers or technical updates.

Verification by uploading an html file

Verification by uploading an HTML file is one of the simplest and most straightforward methods of proving ownership of a site on Google Search Console, but it can only be used for URL prefix properties and not Domain properties. Google generates a unique file that must be uploaded to the site’s root directory, accessible to users through a specific link. This is a great option if we have direct access to the server or file manager of our hosting, but it has limitations for those who rely on platforms without server-side access (e.g.: some website builders).

When to use html file uploading.

This method is ideal for those familiar with managing files on a web server via FTP and SFTP or control panels such as cPanel. It can be chosen when we do not want to edit the HTML code of the site or depend on external tools such as Google Analytics or Tag Manager.

The file can be used on any site we want to verify, it is customized to our user and can be reused; moreover, the verification confirmation is immediate, so if it does not work we have made some mistake! Again, removing the verification file from the site will cause the site to lose its verification.

Practical guide to verification using html files

It only takes a few minutes to complete this procedure. Here are the detailed steps:

Log in to Google Search Console. After logging in, add a URL Prefix property by entering the full URL of the site (e.g., https://www.example.com ) and clicking Continue.
Download the verification HTML file. In the “Recommended Method” section, we select verification by HTML file. Google will generate a unique file, which must be downloaded to the device. The file will have a name similar to html.
Upload the file to the root directory of the site. Using an FTP client (such as FileZilla) or the hosting file manager , we access the site’s base directory, usually referred to as /public_html or /www. Here we will upload the HTML file provided by Google without modifying it in any way. For example:

For https://www.esempio.com, the file must be accessible at the URL https://www.esempio.com/google123456789abcdef.html.

Check the URL in a browser to make sure the file was loaded correctly.

Complete the verification in Search Console. Return to the verification window and click on Verify. If Google is able to access the file at the correct location, the verification will be validated instantly.

Common errors and typical problems

Despite the simplicity of the process, some issues can occur that prevent the verification from completing:

File not found. One of the most common errors is related to the failure to load the file in the correct location. Google cannot find the verification file in the site’s root directory (e.g., /public_html). This often happens when the file is uploaded to the wrong subdirectory, renamed, or accidentally removed. The solution is to check that the file was uploaded exactly as provided by Google, without making any changes to name or content, and that it is accessible at the requested URL (e.g. , https://www.example.com/google12345.html).
Compromised verification file. If the verification attempt fails by returning this error, there may be a more troubling indicator: the site may have been compromised by external attacks or security issues. The solution is to examine the site carefully to identify any signs of compromise or malfunction.
Verification file with disallowed redirection. In some cases, the file may be configured to redirect to a location other than the domain in use. Verification supports redirects within the same domain, but not to different domains. The solution is to access the file and verify that redirects to another domain have not been configured. In the case of overall redirects of all traffic, we recommend using the HTML tag method instead of uploading the file.
Altered or corrupted file. If the file provided by Google is altered, such as by adding lines of text, special characters, or name changes, the system cannot complete the verification. The solution is to use the file exactly as generated by Google Search Console, without any manual intervention in the content or name of the file.

Limitations of the method. This method requires direct access to the server or control panel of the hosting provider. If we use platforms such as Wix, Shopify or other builders where the server is not accessible, it will be necessary to opt for other systems, such as HTML tags or DNS analysis.

Verification by HTML tags

Verification using HTML tags is a very simple and versatile method designed for those who have the ability to modify the source code of their site. This approach consists of adding a specific metatag provided by Google to the <head> section of the site’s home page. It is a particularly useful solution for those who have direct access to the HTML file or those who use CMSs such as WordPress, where code insertion can be managed through plugins or via editors.

When to choose verification with HMTL tags

This method is ideal if we have direct access to the site’s HTML editing capabilities, such as in the case of a static site or configurable CMSs, although it requires permission to edit the source code of the site’s home page in order to proceed with verification with a <meta> tag to the HTML code. It is perfect for those looking for a less technical option than DNS configuration or uploading an HTML file, and is well suited when we need to update verification on an existing site without having to upload new files to the server.

Requirements

To use the HTML tag method, however, we must meet the following requirements:

Home page without authentication: the site’s home page must not require authentication or login to be displayed, thus allowing Googlebot to access the source code.
Access to source code: we must be able to edit the HTML code of the site’s home page by inserting the tag in the <head> section. If we do not have this access, other verification methods should be considered.
Code size: the HTML tag and the file that includes it must not exceed 2 MB. This restriction affects only a few sites with very complex HTML code.
Supported properties: the method is valid only for URL Prefix properties , while Domain properties require the DNS method.

Practical guide to verification with HTML tags

Coming to the practical aspects, the verification process consists of these steps:

Consult the instructions of the provider or CMS. If we are using a website hosting platform or CMS such as WordPress, we consult the service-specific guides for custom directions on how to edit your site’s HTML code. If we do not find adequate guidance, we proceed with the next steps.
Log into Google Search Console. Add a new property by selecting the URL Prefix option , then enter the full address of the site to be verified (e.g. , https://www.example.com).
Select the HTML Tag method. On the verification details screen, select the “Insert HTML Tag” method. Google will provide a unique metatag, which will have a format similar to the following:

Insert the metatag in the <head> section of the home page. Access the HTML code for the site’s home page, using a text editor (for static sites) or a visual editor provided by the CMS platform. Paste the tag provided by Google inside the <head> section . Example:

<html>

<head>

<title>Sample home page</title>.

</head>

<body>

<!– Page content –>

</body>

</html>

Save the changes and publish the modified file or page.
Check that the metatag is visible. Verify that the tag has been correctly inserted by visiting the home page of the published site and consulting its source code. You can press Ctrl+U (or right-click → “View page source”) and search for the string “google-site-verification” to make sure it is positioned correctly.
Complete the verification in Search Console. Go back to the configuration screen in Google Search Console and click on Verification. If the metatag is configured correctly, the property will be verified immediately.

Common mistakes and how to avoid them

Even a seemingly simple method like inserting a metatag can generate problems if not done correctly. Here are the most common errors:

Meta tag not found or placed in the wrong place. The metatag should be placed in the <head> section of the home page, not in other sections of the code. Often the error is due to misplacement, such as being added in the <body> of the page or on pages other than the home page.
Changed metatag content. The metatag generated by Google is unique and should not be modified in any way. Copy and paste the tag exactly as generated by Search Console, avoiding typos or unknowingly adding additional characters.
Outdated site cache. On platforms such as WordPress, the site or browser cache may prevent Google from detecting changes made. Clear the site cache and refresh the page to verify that the tag is visible in the home page source.

Verification with Google Analytics

Verification using the Google Analytics account is a quick and effective method because it takes advantage of the tracking code already installed on the site to confirm ownership in Google Search Console, without further additions to the site. To be valid, however, this procedure requires that the snippet is configured correctly and that our Google account has editing rights on the Google Analytics property linked to the site. It is also important to note that this method works only with URL prefix properties and not for domain type properties.

When to use verification with Google Analytics and necessary requirements

This method is particularly suitable for those who use Analytics regularly and want immediate verification without intervening in the server or HTML code of the site. While simple, it does, however, require certain precautions to be observed:

The home page must be accessible without authentication: the page must not require credentials and be easily viewable by all users and Google crawlers. Secured pages cannot be used for verification purposes or properly accumulate search data.
Editing rights on Google Analytics account: we must have the necessary permissions to edit the Analytics property linked to the site. For Google Analytics 4, the verification tag is associated with a data stream. For earlier versions (Universal Analytics) it is linked to a web property.
Same Google account for Search Console and Analytics: login must be through the same Google account used to set up Google Analytics.
The analytics.js or gtag.js snippet must be in the <head> section: the tracking code must be properly installed at the top of the site home page. Placing it in the <body> section is not supported.
Updated and unmodified code: we use the snippet provided by Google without making any changes to it. Outdated versions or configuration errors will not allow verification.
The HTML file must be less than 2 MB: although this is a rare case, you should pay attention to any excessive size.

Practical guide to verification with Google Analytics

The use of Google Analytics as a verification method is convenient because it takes advantage of a tool that is already configured and familiar, but as mentioned it is tied to the proper implementation and activation of an up-to-date Analytics account. In contexts where the necessary permissions cannot be obtained or Analytics has not yet been installed, it will be appropriate to consider other solutions such as DNS or HTML tags.

However, here are the detailed steps to complete the verification using Google Analytics:

Log into Google Search Console using the Google account that has editing rights in the linked Analytics account. Select the URL Prefix property corresponding to the site to be verified.
Select Google Analytics as the verification method from the verification methods detail page . Search Console will automatically check for the corresponding snippet on the home page.
Verify the configuration of the Analytics snippet on the site. Once the correct snippet configuration is confirmed, the verification will be completed instantly if all requirements are met. No further manual intervention is required.

Common problems and solutions

While the verification is a straightforward method, it may fail if there are technical errors or incomplete configurations. Here are the most common issues reported by Google and recommended solutions:

Monitoring snippet not found. Search Console does not detect a valid monitoring code. We verify that the Analytics snippet is present on the published home page and placed in the <head> section. We use a browser and access the source code to check.
Incorrect code format. The snippet has been altered or does not follow the required format. Let’s make sure we use exactly the snippet provided by Google during configuration. Let’s not change the order or standard parameters.
Obsolete snippet. The code uses old libraries such as urchin.js or gat.js, which are no longer supported. We update the monitoring to Google Analytics 4 by configuring a current data stream.
Snippet in the wrong location. A common mistake is placing the script inside the <body> section or other incompatible sections instead of in the <head> of the page. In these cases, simply move the code to the correct area to allow verification.
Insufficient permissions. We do not have editing rights on the Google Analytics property used. We ask the Analytics account administrator to assign us the necessary permissions or use another verification method.

Verification via Google Tag Manager

As in the previous case, if we already use Google Tag Manager (GTM) on the site to manage tags and scripts we can verify the property in GSC in a convenient and quick way. This method takes advantage of the GTM container snippet already configured on the site and allows us to complete the verification without the need to add new files or manually edit the source code.

When to use verification with Google Tag Manager and requirements needed

This method, like all others that leverage existing scripts, is only compatible with URL prefix properties. It suits those who want to use centralized tools for tracking management and are looking for simple verification based on already active configurations.

Before proceeding with verification using Google Tag Manager, however, we need to check that some requirements are met, and in particular:

The home page must be public and accessible without authentication: there must be no restrictions that limit access to the site by users or Google crawlers. Login-protected pages are not compatible with this method.
Same Google account: you must use the same account to access both Search Console and Google Tag Manager.
Permissions on the GTM container: we must have a sufficient level of access to manage the Google Tag Manager container. Publication or administration rights are required .
The GTM snippet must be in the correct position in the HTML code of the home page. The <noscript> portion must be placed immediately after the opening <body> tag of the page; the <script> code must be within the <head> section of the site, or immediately after the opening of <body>. No breaks or invalid elements, such as data layers or other extraneous elements, may be inserted between the <body> tag and the GTM code.
Unaltered code: the GTM container must be exactly as generated by the Google Tag Manager tool, without alteration.
Size respected: the code must be contained in an HTML file less than 2 MB in size, a limitation that, however, affects only a few very complex sites.

Practical guide to verification with Google Tag Manager

This verification mode reduces the need for manual intervention in the site code by taking advantage of a container already configured for tag management. However, ensuring proper technical implementation is essential to avoid problems related to the location, compatibility or permissions of the GTM container.

So here are the steps to follow to complete the verification using the Google Tag Manager container :

We prepare the GTM container on the site. We verify that the Google Tag Manager code is configured correctly on the site’s home page. The code must adhere to the standard format, to be integrated as follows:

<head>

(function(w,d,s,l,i){w[l]=w[l]|[];w[l].push({‘gtm.start’:new Date().getTime(),event:’gtm.js’});

var f=d.getElementsByTagName(s)[0],

j=d.createElement(s),dl=l!=’dataLayer’?’&l=’+l:”;j.async=true;j.src=

‘https://www.googletagmanager.com/gtm.js?id=’+i+dl;f.parentNode.insertBefore(j,f);

})(window,document,’script’,’dataLayer’,’GTM-XXXXXX’);

</script>

</head>

<body>

height=“0” width=“0” style=“display:none;visibility:hidden”></iframe></noscript>

</body>

We log in to Google Search Console. We log in using the same Google account linked to the GTM container on the site. If necessary, we add a new property with the option URL Prefix, entering the full address of the site.
We select Google Tag Manager as the verification method. On the verification methods screen, we choose the Google Tag Manager option . Search Console will automatically look for the GTM container in the HTML structure of the home page.
Let’s complete the verification. Once the container is found, we click on Verify to complete the process. The process will be immediate if all requirements have been met and the GTM container has been configured correctly.

Common problems and how to solve them

The verification procedure using GTM is relatively simple, but errors can occur that prevent the verification from completing. Here are the most common problems reported by Google and practical solutions:

Tag not found. The Tag Manager container was not detected on the site’s home page. We check that the GTM snippet has been configured correctly and is placed in the home page code. We use a browser to view the published source code and look for the specific ID of our container (e.g., GTM-XXXXXX).
Insufficient permissions. The account being used does not have the necessary permissions to manage the GTM container. We verify that we have publishing or administration privileges for the container in Google Tag Manager. If we do not have these rights, ask the administrator to assign them to us.
Wrong tag or wrong account. The GTM container found on the home page does not match the account used to access Search Console. Let’s make sure we have installed the same GTM container associated with our Google account and the property to be verified.
No Tag Manager container. The container needed for verification has not yet been created in the GTM account. Let’s access Google Tag Manager and create a new container by associating it with the site. Once created, we integrate the provided code into the HTML structure of the home page.
Snippet in the wrong location. The <noscript> or <script> portion of the GTM snippet is not in the required location. We move the code respecting the positioning instructions: <script> in the <head> section ; <noscript> immediately after the opening tag <body>.

Verification with Google Sites

Verifying the ownership of a website created with Google Sites is one of the simplest and most straightforward operations in Google Search Console. Due to the tight integration between Google products, this verification is usually completed automatically, eliminating the need for manual intervention, as long as the site was created and managed using the same Google Account linked to Search Console. However, it is important to consider some specifics related to the version of Google Sites used and the domain configuration.

When to use verification with Google Sites and requirements needed

For sites created with Google Sites, verification of ownership occurs automatically without additional SE configuration:

The site was created using the modern (post-2017) Google Sites platform.
We are accessing Search Console with the same Google Account linked to the site management.

In this scenario, the platform automatically recognizes the user’s identity and completes the verification with a direct connection to the site, without requiring uploading files or adding HTML tags.

To ensure successful automatic or manual verification, we still need to ensure that we comply with the following:

Using the same Google Account: Both Google Sites and Search Console must use the same email address for site management. This is the key point to enable automatic verification.
Validity of Google Sites platform: the site must have been created directly with Google Sites; any configurations with external CMS or custom domains may require additional configuration steps.

If we find ourselves in special cases, however, we must proceed with manual verification, particularly if:

Google Sites with custom domain URL. The site has been associated with a custom domain (e.g., example.com instead of sites .google.com/mysite), which does not make automatic verification possible. In this specific case, we can use the method with Google Analytics or enter the HTML metatag .
Google Sites prior to 2017. Sites created with the classic version of Google Sites, now being phased out, require the use of the HTML tag method to verify the property. This metatag must be integrated directly into the site configuration by following the specific steps available in the platform.

Practical guide to verification with Google Sites

Depending on the specific case, we can follow these steps to complete the verification.

For automatic verification:

We log into Search Console using the same Google Account associated with the site created on Google Sites.
We add the property by selecting the URL Prefix option or directly the public link of the site on Google Sites.
Verification will be completed automatically and immediately.

With Google Analytics:

We configure Google Analytics on the Google Sites site with custom domain.
Let’s make sure the tracking code is correctly implemented on the home page.
Let’s add the property on Search Console and select verification via Analytics.

With HTML tags (for custom domains or classic version) :

We receive the specific HTML tag provided by Search Console.
We access the site configuration on Google Sites and paste the tag in the <head> section .
We return to Search Console and complete the verification by clicking on “Verify”.

Verification with Blogger

Verifying the ownership of a blog created on Blogger is also, as a rule, an automatic and almost immediate process, thanks to the deep integration between this platform and Google Search Console. However, there are some exceptions for older blogs or those configured with custom domains, situations that require manual intervention to complete the verification using an HTML tag.

When to use verification with Blogger and requirements needed

For new blogs created on Blogger, the verification status is automatically recognized by adding the property on Google Search Console with URL Prefix. This occurs when:

We are accessing Search Console with the same Google Account used to manage the blog on Blogger.
The blog is using a standard Blogger URL, of the com type (e.g., nomedelblog.blogspot.com).

This automatic synchronization eliminates any need for additional configuration, making the process smooth and without technical complexities.

However, if the blog uses a custom domain or was created in versions prior to the latest Blogger platform, manual intervention may be required, using HTML Tag verification.

Practical guide to verification with Blogger

Blogger is tightly integrated with Search Console, which greatly simplifies the verification process for most modern blogs using standard Blogger URLs. In more complex cases, just follow these manual options, which still allow you to easily complete the verification.

Here’s how to complete the process step by step:

For automatic verification , valid for modern blogs with standard URLs (blogspot.com):

We log into Google Search Console with the same Google Account used to manage the blog on Blogger.
We add the property by selecting URL Prefix , entering the full URL of the blog (e.g., https://nomedelblog.blogspot.com).
Verification will be completed automatically and immediately without further action.

For blogs with custom or older domains:

We generate an HTML metatag from Google Search Console in the verification section.
We access the Blogger management panel and select the blog to verify.
We go to Theme → Edit HTML and paste the metatag into the <head> section of the blog code.
Let’s go back to Search Console and complete the verification by clicking on “Verify.”

Anyway, if our blog uses a custom domain configured through a provider, we can also opt for verification via DNS records or use a configuration with Google Analytics, if already implemented. Another suggested expedient is to keep the HTML metatag used for the manual method with the metatag, which should remain in the blog configuration so as not to invalidate the verification.

Google site verification, troubleshooting common problems

Although the process of verifying a site in Google Search Console is designed to be accessible and quick, some technical configurations or operational errors can hinder its completion. Problems can arise regardless of the method chosen, and are often the result of small details overlooked during the configuration steps. Understanding these issues and knowing how to solve them is essential to successfully completing the audit.

The first element to respect is where to place the tag within the site so that Google can find it and confirm ownership, which is crucial when we use a tag-based verification method, such as Google Analytics, Google Tag Manager or HTML tag methods . Google Search Console verifies the presence of the tag by looking for it on the page that is loaded as a response to the URL defined in the property.

For example, if we registered a property in Search Console with the URL https://example.com and traffic to this URL is redirected to https://example.com/home, Search Console will look for the verification tag on the page https://example.com/home. It is critical to verify that the tag is actually on the final page reached by the redirect, and not just on the originally defined page.

For other verification methods-such as loading HTML files-redirects are not followed. In these cases, Google will attempt to directly access the specified file in the server’s root directory (e.g., https://example.com/google-verification.html). If the file is not located exactly at the requested URL, the check will be unsuccessful.

Beyond the issues specific to each verification method, some generic errors can then occur that affect the completion of the procedure regardless of the system chosen. These contingencies generally depend on server-side configurations, DNS problems, or errors in file, snippet, or tag handling.

Incorrect tags/snippets/files. The most common error is using a tag, snippet or file that does not match the one provided by Google Search Console. This may be due to accidental changes to the content, file name, or the use of previous values that are no longer valid. To fix it, simply verify that you copied the tag or snippet correctly and that the uploaded file is exactly the same as the one generated by Search Console.
Connection expired while accessing the server. The server may respond too slowly, preventing Google from completing verification. This usually happens when the server is down, overloaded, or has high response times. To fix it, we need to make sure that the server is up and running and that there are no downtime or network errors that can affect connectivity.
Error when searching domain name. Google may not be able to reach the domain during verification due to a DNS error. This problem may arise if the DNS server is not active or if there are issues in routing that prevent proper access to the domain. To resolve, we need to check the DNS configuration of the domain and make sure it is publicly resolvable by checking for any reports from the DNS provider.
Multiple redirects during request. An endless or misconfigured redirect loop can prevent Google from downloading the file or accessing the requested page for verification. This problem is common when the server uses incorrect rules in URL handling. To solve it, we examine the redirect configurations to check for loops or issues that make the URL unreachable.
Invalid response from the server. The server may return an invalid response, such as if the site requires authentication (password) for access or if there are other restrictions in place that prevent Google from accessing the necessary files or data. To resolve, remove temporary restrictions or configure the server to allow access without authentication to complete the verification.
Unable to connect to server. This error indicates that the server cannot be reached, probably due to network problems, downtime, or misconfigurations. To resolve, check the stability of the hosting service and ensure that the domain is fully functional and accessible.
Internal server error. A generic server error can interrupt the verification process, preventing Search Console from completing operations. To resolve it, we need to check the server logs to identify any anomalies or bugs. If the problem persists, consult the provider’s technical support.
Server or domain timeout. A server or domain that stops responding during a request can cause the verification process to fail. This problem is often temporary, but can occur with unstable configurations. To resolve, we must verify that the server is responding correctly to HTTP/HTTPS requests and try again after monitoring the network.
Domain not found. Search Console may not recognize the URL provided, as it may be absent from the DNS service. This happens when the domain is not perfectly configured or not yet propagated. To resolve, we verify that we have entered the property URL correctly, avoiding typos; make sure the domain is configured and propagated correctly by DNS servers.

How to do effective and secure verification

Correctly completing the verification of your site in Google Search Console is only part of the process: keeping the property verified over time and avoiding future problems is also critical. Again, there are some best practices we can adopt to ensure that the verification remains valid and to prevent disruptions in accessing Search Console data and functionality.

These tips are therefore useful not only for those verifying a site for the first time, but also for those managing long-term projects that may undergo technical changes.

Maintain verification files and permissions even after confirmation

We’ve said it: it is wrong to remove the HTML file, metatag or DNS record used for verification immediately after completing the procedure. This behavior can lead to a loss of permissions, as Google periodically checks for the presence of the token to confirm ownership. Therefore, depending on the method chosen, after verification, we should not delete the DNS TXT/CNAME record from the domain provider’s panel; we should not remove the HTML file uploaded to the site’s root directory, checking that it remains accessible; and we should not touch the HTML metatags or Google Analytics/Tag Manager snippets in the source code. If any of these elements are removed or modified, Search Console may no longer be able to verify the property, limiting access to data and functionality.

Use multiple verification methods to maximize stability

This is a practical tip that comes directly from Daniel Waisberg of Google: using multiple verification methods gives us more assurance that at least one will succeed in case of problems, errors or difficulties.

In short: relying on only one verification method can be limiting, especially if the site undergoes technical changes over time. For example, if an HTML file is accidentally removed, a tag in DNS permissions stops working, or the header code is overwritten, we may lose the verified property. Using multiple verification methods is one expedient that allows us to maintain uninterrupted access, increasing the resilience of the system. Where possible, therefore, we can configure a DNS record even if we have chosen another method, because it is the most durable and independent of the internal structure of the site. Or, insert an HTML metatag as a backup if we have access to the source code or use CMS systems that easily support it. Again, if we use tools such as Google Analytics or GTM , it is useful to leverage these integrations as secondary methods as well.

Diversifying verification systems ensures continuity, even if changes are made that invalidate the original method (e.g., theme change on WordPress or technical restructuring of the server).

Regularly monitor the validity of the verification token

Google periodically checks for the presence of the verification token (be it a file, an HTML tag, or a DNS record), but does not send any prior notification if this validity is compromised. Therefore, it is important to personally verify at regular intervals that all tokens are still correct and accessible. Specifically, we need to scan the source code of the site to verify that the HTML metatag or snippet used is still visible; access the DNS panel to confirm that the record associated with Search Console is present and active; and test access to the uploaded HTML file by running a direct check via a browser: the file should remain publicly available at the indicated URL.

If we plan to make technical changes or site migrations, such as template replacements, hosting changes, or page restructurings, we should verify that all token-related elements remain unchanged.

Adopt a shared management strategy to ensure continuity

Again for “protection,” although each property verified in Google Search Console requires at least one owner, it would be best to add a few more, both for security and access convenience.

This is especially true for projects managed by teams or agencies, where adding multiple verified owners in Search Console is a critical step to ensure that site management is not disrupted due to a change in roles or loss of access by a single administrator.

In particular, we need to ensure that each verified owner uses a robust verification method (such as DNS record) and that when a team member leaves the project, the relevant verification token is removed to prevent unauthorized access.

In addition, it is good to know that we can check the list of verified owners at any time and possibly proceed to remove these privileges, so that they are not allowed access to business data.

Verifying websites with google search console, the FAQ

Although it is a technical step, verifying a site for Google Search Console has become more flexible over time due to the availability of several adaptable methods and options. In spite of this, there is no shortage of special cases, errors or curiosities that arise during the configuration phase, so it can be useful to gather in a single section the answers to the most common doubts of users.

From timing to technical requirements, from solutions to problems with DNS and HTML tags to useful tools for the main CMSs, we make the final point to ensure an effective and uncomplicated verification.

How to know if a site is verified on Google?

To check if our site is properly verified on Google Search Console, we access the platform’s dashboard with the linked account. In the list of properties, the verified site will appear as active and, next to the name, the verification method used (e.g., DNS or HTML tag) will be indicated.

Another way to verify the status is to visit the Settings → Verify Properties section of Search Console, where we can confirm that the verification token is still valid. If the method is no longer valid (for example, due to a DNS record or file being changed or removed), we will need to repeat the procedure to restore it.

How long does it take Google to verify a site?

The verification time depends on the method you choose. Basic:

For methods such as HTML tags, HTML files or Google Analytics the verification is instantaneous, provided the token is properly configured and accessible.
With the DNS record method, the process can take longer, as the propagation of DNS changes can take from a few minutes to up to 48 hours, depending on the domain provider, the global network involved and the configuration adopted.

If the verification is not completed immediately, wait a few hours and try again.

Is it possible to verify a site without accessing the server?

Yes, we can verify a site even without intervening directly on the server, using one of the following methods:

HTML tags: we can add the provided metatag in the <head> section of the site using a visual editor or a platform plugin (for example, WordPress offers dedicated tools for this functionality).
Google Analytics or Google Tag Manager: if these tools are already configured on the site, they can be used to complete the verification without having to upload files or modify server-side configurations.
Google Sites or Blogger: if our site is hosted on these platforms, verification may occur automatically if we use the same Google account for Search Console.

In case the chosen method requires more technical access, we can ask for support from whoever manages the server.

Why can’t I verify my dns?

Verification problems with DNS records can result from several causes. The most common reasons include:

TXT or CNAME record configuration error: the record was not added correctly in the DNS section of the provider’s control panel, or incorrect values were entered for the “Name” or “Value” field.
Incomplete propagation: it can take up to 48 hours for the record to become fully visible on all DNS servers.
Conflicts with other DNS configurations: the record created may have been overwritten by another.

We verify that we have configured the DNS record correctly and use tools such as DNS Checker to check that it is publicly visible. If the problem persists, we can contact DNS provider support.

What is the Google verification code for?

The Google verification code is a unique token that demonstrates to Search Console that we have legitimate control of our indicated site or domain. It can be generated in the forms of an HTML metatag, an HTML file, a DNS TXT record or an embedded snippet via Analytics or Tag Manager.

The purpose of this token is to allow Google to associate ownership with those who manage the technical configurations of the site, protecting sensitive data and preventing unauthorized third parties from accessing reports and advanced Search Console features.

What tools are useful for verification in major CMSs?

Many CMSs offer tools to simplify verification with Google Search Console, eliminating the need to make manual changes to files or code. Here are some of the most common ones:

WordPress Plugins: Insert Headers and Footers or Yoast SEO allow you to quickly integrate HTML metatags. The Site Kit by Google plugin allows you to link your site directly to Search Console and other Google tools.
Wix offers a built-in interface for entering verification code directly from SEO settings without technical intervention.
Shopify: from the Preferences dashboard we can paste the HTML tag provided by Search Console.
Joomla/Drupal: through dedicated modules we can integrate the HTML tag or configure tools such as Google Analytics or Tag Manager, simplifying the verification process.

Each CMS has its own official documentation on verification procedures, and often offers support to simplify the more technical steps. Whenever possible, consult official guides or established plugins to ensure a smooth and secure process.

Before proceeding, it is always helpful to consult the official documentation of the CMS you are using to locate specific guides and compatible tools to facilitate the procedure.

What was the preferred domain setting in Search Console?

Until a few years ago, there was a tool in the old version of Search Console that allowed the user to set the preferred domain (between example.com rather than www.example.com) to determine how the website was then shown in the SERP.

Always stay one step ahead

Combine SEOZoom and Search Console to monitor SERP movements and get ahead of your competitors

Find out more

The preferred domain setting was a feature inherited from Google Webmaster Tools that, in a very intuitive way, allowed site owners to tell Google the preferred domain to be used to index the site’s pages, i.e., the canonical domain, by simply selecting one of the available options. The setting was useful in frequent cases where a site had the same content on multiple URLs, such as, the Google article explains, http://example.com/ or https://www.example.com/index.html.

This feature was officially removed in 2019, as recalled in this article wryly titled “Bye Bye Preferred Domain setting, ” in which Daniel Waisberg addresses the company’s decision to no longer allow webmasters to manually choose in Search Console the preferred version of the URL to monitor.

As its system continues to evolve, Google has become able to choose a site’s preferred domain based on the various signals provided during setup, and thus essentially manual selection has become unnecessary. Now, the search engine is able to automatically choose a URL as “canonical” for searching when they identify what they consider to be “the best option” (best option), but users can facilitate the process by signaling their preference in various technical ways.

One important element is that when the deprecation of the preferred domain setting is complete, Google will no longer use the previous configurations set, proceeding directly with the new selection criterion. Just to be on the safe side, we have at least four methods to tell Google which preferred domain URL to follow:

Using the rel canonical link tag in HTML pages.
Use the HTTP rel canonical header .
Use a sitemap.
Use 301 redirects from withdrawn Urls .

What is domain property in Google Search Console and what benefits does it provide?

Domain property is a feature that simplifies the monitoring of all variants of a domain within Google Search Console by aggregating data on:

Protocols (http/https).
Subdomains (e.g., www, m., blog).
Subpaths on the site.

Thanks to this configuration, which replaced the previous property set, we can analyze SEO data for the entire domain in a unified way, avoiding the need to create and verify each variant separately. In addition, Google allows us to segment the data by subdomain, protocol, or secondary path, should it be useful for more specific analysis. Until the previous version, in fact, webmasters and site owners had to verify the various properties individually each time, whereas this simplifies procedures and reduces time.

To configure a domain property, it is necessary to verify the property using a DNS record, which is a prerequisite for demonstrating control over the entire domain. This feature is particularly appreciated by those who manage multiple variants of a site or complex projects, because it reduces data fragmentation and simplifies the overall monitoring of organic visibility in Google Search.