Request Google's Page-rank Programmatically

• Download source code - 515 KB

Introduction

Google's PageRank (PR) is a "link analysis algorithm measuring the relative importance" (PR @wikipedia). The importance of PR nowadays is a lot lower than one or two years ago. Nevertheless, PR is the only ranking value that is public to all audience, which means it's the only factor with some transparency. For those who don't know: a PR of 10 is the highest around (like for apple.com), and 0 the lowest - those sites who don't even have a PR of 0 are in a kind of sandbox (a special filter to punish the site) or not indexed by Google.

Please forgive me for being lazy during English lessons @ school as I'm trying my best :)

Background

Google tries to measure the relevance of a domain/site by counting the links pointing to the site/domain. This is influenced by the number of links that link to the linking site - in fact, this kind of procedure is an iterative process, which needs a lot of computing power.

Many webmasters believe their ranking depends on the PR of their site - this, today, is not true. PR never was the only factor for Google's ranking, but it was the most important factor. Right now, it's not. And many people believe that Google tries to get rid of the PageRank because link traders are measuring the value (in $) of a link by PR - which is just stupid.

If you're interested in buying links, go with the following factors:

• Link popularity (how often is the site, you're willing to buy a link from, linked?)
• Domain popularity (^ + by different domains)
• IP-popularity (^ + on different IPs)
• Has the domain an "authority status"?
• Is the content of the domain relevant for your content?
• Has this domain a good ranking for keywords you want to rank good at?
• How many outgoing links does this site have?

Because PR is the one and only factor we can have a look at, it's pretty nice to check it. And it's even more nice if we can do that on more than one Google data center at the same time.

Requesting the PR

Well, the easy part is the PR get request: it's just a simple HTTP-Request, with a little problem in it. Here's the request for www.codeproject.com:

http://toolbarqueries.google.com/search?client=navclient-auto&hl=en&ch=6771535612&ie=UTF-8
    &oe=UTF-8&features=Rank&q=info:http%3A%2F%2Fwww.codeproject.com%2F

Well, this seems to be easy, but there's this little:

ch=6771535612

which is a hash value referencing the domain we want to get the PR for. This hashing algorithm was not developed by Google, it's the perfect hashing algorithm by Bob Jenkins.

After some folks ported the code to PHP, I tried to do a port to C# - and here we go.

But before that, I need to mention that (after I finished my coding) I found another port by Miroslav Stompar, which you can find here.

To be honest, his port is better, so I modified my version, and here comes the solution that's my favorite: .

Ported to C#

using System;
using System.Collections.Generic;
using System.Text;  
using System.Text.RegularExpressions;
using System.Net;
using System.IO;

namespace GooglePR
{
    class GetPR
    {
        private const UInt32 myConst = 0xE6359A60;
        private static void _Hashing(ref UInt32 a, ref UInt32 b, ref UInt32 c)
        {
            a -= b; a -= c; a ^= c >> 13;
            b -= c; b -= a; b ^= a << 8;
            c -= a; c -= b; c ^= b >> 13;
            a -= b; a -= c; a ^= c >> 12;
            b -= c; b -= a; b ^= a << 16;
            c -= a; c -= b; c ^= b >> 5;
            a -= b; a -= c; a ^= c >> 3;
            b -= c; b -= a; b ^= a << 10;
            c -= a; c -= b; c ^= b >> 15;
        }
        public static string PerfectHash(string theURL)
        {
            url = string.Format("info:{0}", theURL);

            int length = url.Length;
            
            UInt32 a, b;
            UInt32 c = myConst;

            int k = 0;
            int len = length;

            a = b = 0x9E3779B9;

            while (len >= 12)
            {
                a += (UInt32)(url[k + 0] + (url[k + 1] << 8) + 
                     (url[k + 2] << 16) + (url[k + 3] << 24));
                b += (UInt32)(url[k + 4] + (url[k + 5] << 8) + 
                     (url[k + 6] << 16) + (url[k + 7] << 24));
                c += (UInt32)(url[k + 8] + (url[k + 9] << 8) + 
                     (url[k + 10] << 16) + (url[k + 11] << 24));
                _Hashing(ref a, ref b, ref c);
                k += 12;
                len -= 12;
            }
            c += (UInt32)length;
            switch (len) 
            {
                case 11: 
                    c += (UInt32)(url[k + 10] << 24); 
                    goto case 10;
                case 10: 
                    c += (UInt32)(url[k + 9] << 16); 
                    goto case 9;
                case 9: 
                    c += (UInt32)(url[k + 8] << 8); 
                    goto case 8;
                case 8: 
                    b += (UInt32)(url[k + 7] << 24); 
                    goto case 7;
                case 7: 
                    b += (UInt32)(url[k + 6] << 16); 
                    goto case 6;
                case 6: 
                    b += (UInt32)(url[k + 5] << 8); 
                    goto case 5;
                case 5: 
                    b += (UInt32)(url[k + 4]); 
                    goto case 4;
                case 4: 
                    a += (UInt32)(url[k + 3] << 24); 
                    goto case 3;
                case 3: 
                    a += (UInt32)(url[k + 2] << 16); 
                    goto case 2;
                case 2: 
                    a += (UInt32)(url[k + 1] << 8); 
                    goto case 1;
                case 1: 
                    a += (UInt32)(url[k + 0]); 
                    break;
                default: 
                    break;
            }
            
            _Hashing(ref a, ref b, ref c);

            return string.Format("6{0}", c);
        }

        public static int MyPR(string myURL)
        {
            string strDomainHash = PerfectHash(myURL);
            string myRequestURL = string.Format("http://toolbarqueries.google.com/" + 
                   "search?client=navclient-auto&ch={0}&features=Rank&q=info:{1}", 
                   strDomainHash, myURL);

            try
            {
                HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(myRequestURL);
                string myResponse = new StreamReader(
                       myRequest.GetResponse().GetResponseStream()).ReadToEnd();
                if (myResponse.Length == 0)
                    return 0;
                else
                    return int.Parse(Regex.Match(myResponse, 
                           "Rank_1:[0-9]:([0-9]+)").Groups[1].Value);
            }
            catch (Exception)
            {
                return -1;
            }
        }

    }
}

So many thanks to Miroslav, who did the better job :)

Example: An ASP.NET Version

Here you can find the ASP.NET version of a PR-Checker - this one checks the PR of a domain/site of different IPs, which means different Google data centers. Because Google only updates the shown PR (Toolbar PR) about every 3 months, this tool is nice to check, if there's an update running - while the update runs, you'll get different PRs for the same page (in case the PR raises or falls) - interesting, isn't it?

To check more than one data center, I just created a loop and dynamically replace the:

toolbarqueries.google.com

part of the request with a Google IP - a list of IPs can be found via Google :)

If the tool shows "-1", the PR couldn't be retrieved, due to any reason.

History

• 0.2 - Uploaded source code

I got to mention something first: if you're using the uploaded example, then you are using the code by miro stampar - for some reasons, my code is blown up with other things, and I'm still working on it. So don't worry about why the code differs from the code in this article.

• 0.1 - Correction of a variable name (myURL to url) - thx to CP-user ploufs :)