Tab Mapper

Tab or chord file URL

The tab mapper is a handy little tool that will render a guitar tab file with graphic chord diagrams displayed alongside. This comes in handy for people who just don't have every single chord shape memorized. Just plug in the web site address of a valid .tab or .crd file and hit "Go". In general, the tab mapper does a better job with printer friendly URLs. If there is more than one way to play a chord, the tab mapper will choose the most common shape. To see other fingerings, click on the chord diagram and you will be taken to the chord calculator.

Original file located @ http://novada.com.

              
  curl -x super.novada.pro:7777 -U "USER-zone-resi:PASS" ipinfo.novada.pro
              
            

              
  import requests

  username = "USER-zone-resi"
  password = "PASS"
  proxy = "super.novada.pro:7777"
  
  proxies = {
    'http': f'http://{username}:{password}@{proxy}',
    'https': f'http://{username}:{password}@{proxy}'
  }
  
  response = requests.request(
      'GET',
      'https://ipinfo.novada.pro',
      proxies=proxies,
  )
  
  print(response.text)
              
            

                  
  import fetch from 'node-fetch';
  import createHttpsProxyAgent from 'https-proxy-agent'
  
  const username = 'USER-zone-resi';
  const password = 'PASS';
  const proxy = 'super.novada.pro:7777'
  
  const agent = createHttpsProxyAgent(
    `http://${username}:${password}@${proxy}`
  );
  
  const response = await fetch('https://ipinfo.novada.pro', {
    method: 'get',
    agent: agent,
  });
  
  console.log(await response.text());
                  
              

                            
  <?php

  $username = 'USER-zone-resi';
  $password = 'PASS';
  $proxy = 'super.novada.pro:7777';
  
  $query = curl_init('https://ipinfo.novada.pro');
  
  curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
  curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
  
  $output = curl_exec($query);
  curl_close($query);
  if ($output)
      echo $output;
                              ?>
                            
                        

                            
  package main

  import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
  )
  
  func main() {
    const username = "USER-zone-resi"
    const password = "PASS"
    const proxy = "super.novada.pro:7777"
  
    proxyUrl, _ := url.Parse(
      fmt.Sprintf(
        "http://%s:%s@%s",
        username,
        password,
        proxy,
      ),
    )
  
    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
    request, _ := http.NewRequest("GET",
      "https://ipinfo.novada.pro",
      nil,
    )
  
    request.SetBasicAuth(username, password)
    response, err := client.Do(request)
    if err != nil {
      fmt.Println(err)
      return
    }
  
    responseText, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(responseText))
  }

                            
                        

                            
  package example;

  import org.apache.http.HttpHost;
  import org.apache.http.client.fluent.*;
  
  public class Main {
    public static void main(String[] args) throws Exception {
  
      String username = "USER-zone-resi";
      String password = "PASS";
      String proxyHost = "super.novada.pro";
      int proxyPort = 7777;
  
      HttpHost entry = new HttpHost(proxyHost, proxyPort);
      String query = Executor.newInstance()
          .auth(entry, username, password)
          .execute(Request.Get("https://ipinfo.novada.pro")
          .viaProxy(entry))
          .returnContent()
          .asString();
      System.out.println(query);
    }
                              }
                            
                        

                            
  using System;
  using System.Net;
  
  class Example
  {
    static void Main()
    {   
      var username = "USER-zone-resi";
      var password = "PASS";
      var proxy = "super.novada.pro:7777";
  
      var client = new WebClient();
      client.Proxy = new WebProxy(proxy);
      client.Proxy.Credentials = new NetworkCredential(username, password);
      Console.WriteLine(client.DownloadString("https://ipinfo.novada.pro"));
    }
  }
                            
                        

                            
  curl -x ip:8886 -U "USER:PASS" ipinfo.novada.pro
                            
                        

                            
  import requests

  username = "USER"
  password = "PASS"
  proxy = "ip:8886"

  proxies = {
    'http': f'http://{username}:{password}@{proxy}',
    'https': f'http://{username}:{password}@{proxy}'
  }

  response = requests.request(
      'GET',
      'https://ipinfo.novada.pro',
      proxies=proxies,
  )

  print(response.text)
                            
                        

                            
  import fetch from 'node-fetch';
  import createHttpsProxyAgent from 'https-proxy-agent'

  const username = 'USER';
  const password = 'PASS';
  const proxy = 'ip:8886'

  const agent = createHttpsProxyAgent(
    `http://${username}:${password}@${proxy}`
  );

  const response = await fetch('https://ipinfo.novada.pro', {
    method: 'get',
    agent: agent,
  });

  console.log(await response.text());
                            
                        

                            
  <?php

  $username = 'USER';
  $password = 'PASS';
  $proxy = 'ip:8886';

  $query = curl_init('https://ipinfo.novada.pro');

  curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
  curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");

  $output = curl_exec($query);
  curl_close($query);
  if ($output)
      echo $output;
  ?>
                            
                        

                            
  package main

  import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
  )

  func main() {
    const username = "USER"
    const password = "PASS"
    const proxy = "ip:8886"

    proxyUrl, _ := url.Parse(
      fmt.Sprintf(
        "http://%s:%s@%s",
        username,
        password,
        proxy,
      ),
    )

    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
    request, _ := http.NewRequest("GET",
      "https://ipinfo.novada.pro",
      nil,
    )

    request.SetBasicAuth(username, password)
    response, err := client.Do(request)
    if err != nil {
      fmt.Println(err)
      return
    }

    responseText, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(responseText))
  }


                            
                        

                            
  package example;

  import org.apache.http.HttpHost;
  import org.apache.http.client.fluent.*;

  public class Main {
    public static void main(String[] args) throws Exception {

      String username = "USER";
      String password = "PASS";
      String proxyHost = "ip";
      int proxyPort = 8886;

      HttpHost entry = new HttpHost(proxyHost, proxyPort);
      String query = Executor.newInstance()
          .auth(entry, username, password)
          .execute(Request.Get("https://ipinfo.novada.pro")
          .viaProxy(entry))
          .returnContent()
          .asString();
      System.out.println(query);
    }
  }
                            
                        

                            
  using System;
  using System.Net;

  class Example
  {
    static void Main()
    {   
      var username = "USER";
      var password = "PASS";
      var proxy = "ip:8886";  

      var client = new WebClient();
      client.Proxy = new WebProxy(proxy);
      client.Proxy.Credentials = new NetworkCredential(username, password);
      Console.WriteLine(client.DownloadString("https://ipinfo.novada.pro"));
    }
  }
                            
                        

                            
curl -x super.novada.pro:7777 -U "USER-zone-isp:PASS" ipinfo.novada.pro
                            
                        

                            
  import requests

  username = "USER-zone-isp"
  password = "PASS"
  proxy = "super.novada.pro:7777"
  
  proxies = {
    'http': f'http://{username}:{password}@{proxy}',
    'https': f'http://{username}:{password}@{proxy}'
  }
  
  response = requests.request(
      'GET',
      'https://ipinfo.novada.pro',
      proxies=proxies,
  )
  
  print(response.text)
                            
                        

                            
  import fetch from 'node-fetch';
  import createHttpsProxyAgent from 'https-proxy-agent'
  
  const username = 'USER-zone-isp';
  const password = 'PASS';
  const proxy = 'super.novada.pro:7777'
  
  const agent = createHttpsProxyAgent(
    `http://${username}:${password}@${proxy}`
  );
  
  const response = await fetch('https://ipinfo.novada.pro', {
    method: 'get',
    agent: agent,
  });
  
  console.log(await response.text());
                            
                        

                            
  <?php

  $username = 'USER-zone-isp';
  $password = 'PASS';
  $proxy = 'super.novada.pro:7777';
  
  $query = curl_init('https://ipinfo.novada.pro');
  
  curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
  curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
  
  $output = curl_exec($query);
  curl_close($query);
  if ($output)
      echo $output;
  ?>
                            
                        

                            
  package main

  import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
  )
  
  func main() {
    const username = "USER-zone-isp"
    const password = "PASS"
    const proxy = "super.novada.pro:7777"
  
    proxyUrl, _ := url.Parse(
      fmt.Sprintf(
        "http://%s:%s@%s",
        username,
        password,
        proxy,
      ),
    )
  
    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
    request, _ := http.NewRequest("GET",
      "https://ipinfo.novada.pro",
      nil,
    )
  
    request.SetBasicAuth(username, password)
    response, err := client.Do(request)
    if err != nil {
      fmt.Println(err)
      return
    }
  
    responseText, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(responseText))
  }                              

                            
                        

                            
  package example;

  import org.apache.http.HttpHost;
  import org.apache.http.client.fluent.*;
  
  public class Main {
    public static void main(String[] args) throws Exception {
  
      String username = "USER-zone-isp";
      String password = "PASS";
      String proxyHost = "super.novada.pro";
      int proxyPort = 7777;
  
      HttpHost entry = new HttpHost(proxyHost, proxyPort);
      String query = Executor.newInstance()
          .auth(entry, username, password)
          .execute(Request.Get("https://ipinfo.novada.pro")
          .viaProxy(entry))
          .returnContent()
          .asString();
      System.out.println(query);
    }
  }
                            
                        

                            
  using System;
  using System.Net;
  
  class Example
  {
    static void Main()
    {   
      var username = "USER-zone-isp";
      var password = "PASS";
      var proxy = "super.novada.pro:7777";
  
      var client = new WebClient();
      client.Proxy = new WebProxy(proxy);
      client.Proxy.Credentials = new NetworkCredential(username, password);
      Console.WriteLine(client.DownloadString("https://ipinfo.novada.pro"));
    }
  }
                            
                        

                            
  curl -x super.novada.pro:7777 -U "USER-zone-static:PASS" ipinfo.novada.pro
                            
                        

                            
  import requests

  username = "USER-zone-static"
  password = "PASS"
  proxy = "super.novada.pro:7777"

  proxies = {
    'http': f'http://{username}:{password}@{proxy}',
    'https': f'http://{username}:{password}@{proxy}'
  }

  response = requests.request(
      'GET',
      'https://ipinfo.novada.pro',
      proxies=proxies,
  )

  print(response.text)
                            
                        

                            
  import fetch from 'node-fetch';
  import createHttpsProxyAgent from 'https-proxy-agent'

  const username = 'USER-zone-static';
  const password = 'PASS';
  const proxy = 'super.novada.pro:7777'

  const agent = createHttpsProxyAgent(
    `http://${username}:${password}@${proxy}`
  );

  const response = await fetch('https://ipinfo.novada.pro', {
    method: 'get',
    agent: agent,
  });

  console.log(await response.text());
                            
                        

                            
  <?php

  $username = 'USER-zone-static';
  $password = 'PASS';
  $proxy = 'super.novada.pro:7777';

  $query = curl_init('https://ipinfo.novada.pro');

  curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
  curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");

  $output = curl_exec($query);
  curl_close($query);
  if ($output)
      echo $output;
  ?>
                            
                        

                            
  package main

  import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
  )

  func main() {
    const username = "USER-zone-static"
    const password = "PASS"
    const proxy = "super.novada.pro:7777"

    proxyUrl, _ := url.Parse(
      fmt.Sprintf(
        "http://%s:%s@%s",
        username,
        password,
        proxy,
      ),
    )

    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
    request, _ := http.NewRequest("GET",
      "https://ipinfo.novada.pro",
      nil,
    )

    request.SetBasicAuth(username, password)
    response, err := client.Do(request)
    if err != nil {
      fmt.Println(err)
      return
    }

    responseText, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(responseText))
  }

                            
                        

                            
  package example;

  import org.apache.http.HttpHost;
  import org.apache.http.client.fluent.*;

  public class Main {
    public static void main(String[] args) throws Exception {

      String username = "USER-zone-static";
      String password = "PASS";
      String proxyHost = "super.novada.pro";
      int proxyPort = 7777;

      HttpHost entry = new HttpHost(proxyHost, proxyPort);
      String query = Executor.newInstance()
          .auth(entry, username, password)
          .execute(Request.Get("https://ipinfo.novada.pro")
          .viaProxy(entry))
          .returnContent()
          .asString();
      System.out.println(query);
    }
  }
                            
                        

                            
  using System;
  using System.Net;

  class Example
  {
    static void Main()
    {   
      var username = "USER-zone-static";
      var password = "PASS";
      var proxy = "super.novada.pro:7777";

      var client = new WebClient();
      client.Proxy = new WebProxy(proxy);
      client.Proxy.Credentials = new NetworkCredential(username, password);
      Console.WriteLine(client.DownloadString("https://ipinfo.novada.pro"));
    }
  }
                            
                        

                            
  curl -x ip:8886 -U "USER:PASS" ipinfo.novada.pro
                            
                        

                            
  import requests

  username = "USER"
  password = "PASS"
  proxy = "ip:8886"

  proxies = {
    'http': f'http://{username}:{password}@{proxy}',
    'https': f'http://{username}:{password}@{proxy}'
  }

  response = requests.request(
      'GET',
      'https://ipinfo.novada.pro',
      proxies=proxies,
  )

  print(response.text)
                            
                        

                            
  import fetch from 'node-fetch';
  import createHttpsProxyAgent from 'https-proxy-agent'

  const username = 'USER';
  const password = 'PASS';
  const proxy = 'ip:8886'

  const agent = createHttpsProxyAgent(
    `http://${username}:${password}@${proxy}`
  );

  const response = await fetch('https://ipinfo.novada.pro', {
    method: 'get',
    agent: agent,
  });

  console.log(await response.text());
                            
                        

                            
  <?php

  $username = 'USER';
  $password = 'PASS';
  $proxy = 'ip:8886';

  $query = curl_init('https://ipinfo.novada.pro');

  curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
  curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");

  $output = curl_exec($query);
  curl_close($query);
  if ($output)
      echo $output;
  ?>
                            
                        

                            
  package main

  import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
  )

  func main() {
    const username = "USER"
    const password = "PASS"
    const proxy = "ip:8886"

    proxyUrl, _ := url.Parse(
      fmt.Sprintf(
        "http://%s:%s@%s",
        username,
        password,
        proxy,
      ),
    )

    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
    request, _ := http.NewRequest("GET",
      "https://ipinfo.novada.pro",
      nil,
    )

    request.SetBasicAuth(username, password)
    response, err := client.Do(request)
    if err != nil {
      fmt.Println(err)
      return
    }

    responseText, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(responseText))
  }

                            
                        

                            
  package example;

  import org.apache.http.HttpHost;
  import org.apache.http.client.fluent.*;

  public class Main {
    public static void main(String[] args) throws Exception {

      String username = "USER";
      String password = "PASS";
      String proxyHost = "ip";
      int proxyPort = 8886;

      HttpHost entry = new HttpHost(proxyHost, proxyPort);
      String query = Executor.newInstance()
          .auth(entry, username, password)
          .execute(Request.Get("https://ipinfo.novada.pro")
          .viaProxy(entry))
          .returnContent()
          .asString();
      System.out.println(query);
    }
  }
                            
                        

                            
  using System;
  using System.Net;

  class Example
  {
    static void Main()
    {   
      var username = "USER";
      var password = "PASS";
      var proxy = "ip:8886";  

      var client = new WebClient();
      client.Proxy = new WebProxy(proxy);
      client.Proxy.Credentials = new NetworkCredential(username, password);
      Console.WriteLine(client.DownloadString("https://ipinfo.novada.pro"));
    }
  }
                            
                        

              
  curl  -x unblock.novada.pro:7799 -U "account-zone-unblock:password" -H "X-Novada-Render-Type:html" "https://www.google.com"  -k > google.html 
              
            

              
  import requests

  # Use your Web Unblocker credentials here.
  USERNAME, PASSWORD = 'account-zone-unblock', 'password'
  
  # Define proxy dict.
  proxies = {
    'http': f'http://{USERNAME}:{PASSWORD}@unblock.novada.pro:7799',
    'https': f'https://{USERNAME}:{PASSWORD}@unblock.novada.pro:7799',
  }
  
  headers = {
      'X-Novada-Render-Type': 'html',
            } 
  
  response = requests.get(
      'https://www.google.com',
      verify=False,  # It is required to ignore certificate
      proxies=proxies,
      headers=headers,
  )
  
  # Print result page to stdout
  print(response.text)
  
  # Save returned HTML to result.html file
  with open('result.html', 'w') as f:
      f.write(response.text)
              
            

                  
  import fetch from 'node-fetch';
  import { HttpsProxyAgent } from 'https-proxy-agent';
  
  const username = 'account-zone-unblock';
  const password = 'password';
  
  const agent = new HttpsProxyAgent(
          "https://account-zone-unblock:[email protected]:7799"
  );
  
  // We recommend accepting our certificate instead of allowing insecure (http) traffic
  process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = 0;
  
  const headers = {
     'X-Novada-Render-Type': 'html',
            }
  
  const response = await fetch('https://www.google.com', {
    method: 'get',
    headers: headers,
    agent: agent,
  });
  
  console.log(await response.text());               
                  
              

                            
  <?php
  $ch = curl_init();
  
  curl_setopt($ch, CURLOPT_URL, 'https://www.google.com');
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($ch, CURLOPT_PROXY, 'unblock.novada.pro:7799');
  curl_setopt($ch, CURLOPT_PROXYUSERPWD, 'account-zone-unblock' . ':' . 'password');
  curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
  
  curl_setopt_array($ch, array(
      CURLOPT_HTTPHEADER  => array(
          'X-Novada-Render-Type: html',
      )
  ));
  
  $result = curl_exec($ch);
  echo $result;
  
  if (curl_errno($ch)) {
      echo 'Error:' . curl_error($ch);
  }
  curl_close($ch);
                            
                        

                            
  package main

  import (
    "crypto/tls"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
  )
  
  func main() {
    const Username = "account-zone-unblock"
    const Password = "password"
  
    proxyUrl, _ := url.Parse(
      fmt.Sprintf(
        "https://%s:%[email protected]:7799",
        Username,
        Password,
      ),
    )
    customTransport := &http.Transport{Proxy: http.ProxyURL(proxyUrl)}
  
    // We recommend accepting our certificate instead of allowing insecure (http) traffic
    customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
  
    client := &http.Client{Transport: customTransport}
    request, _ := http.NewRequest("GET",
      "https://www.google.com",
      nil,
    )
    
    // Add custom cookies
          request.Header.Add("X-Novada-Render-Type", "html")
    request.SetBasicAuth(Username, Password)
    response, _ := client.Do(request)
  
    responseText, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(responseText))
  }
                            
                        

                            
  package org.example;

  import org.apache.hc.client5.http.auth.AuthScope;
  import org.apache.hc.client5.http.auth.CredentialsProvider;
  import org.apache.hc.client5.http.classic.methods.HttpGet;
  import org.apache.hc.client5.http.config.RequestConfig;
  import org.apache.hc.client5.http.impl.auth.CredentialsProviderBuilder;
  import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
  import org.apache.hc.client5.http.impl.classic.HttpClients;
  import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
  import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
  import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder;
  import org.apache.hc.client5.http.ssl.TrustAllStrategy;
  import org.apache.hc.core5.http.HttpHost;
  import org.apache.hc.core5.http.io.entity.EntityUtils;
  import org.apache.hc.core5.http.message.StatusLine;
  import org.apache.hc.core5.ssl.SSLContextBuilder;
  
  import java.util.Arrays;
  import java.util.Properties;
  
  
  public class Main {
  
      public static void main(final String[] args)throws Exception {
          final CredentialsProvider credsProvider = CredentialsProviderBuilder.create()
                  .add(new AuthScope("unblock.novada.pro:7799), "account-zone-unblock", "password".toCharArray())
                  .build();
          final HttpHost target = new HttpHost("https:", "www.google.com", 443);
          final HttpHost proxy = new HttpHost("https", "unblock.novada.pro", 7799);
          try (final CloseableHttpClient httpclient = HttpClients.custom()
                  .setDefaultCredentialsProvider(credsProvider)
                  .setProxy(proxy)
                  // We recommend accepting our certificate instead of allowing insecure (http) traffic
                  .setConnectionManager(PoolingHttpClientConnectionManagerBuilder.create()
                          .setSSLSocketFactory(SSLConnectionSocketFactoryBuilder.create()
                                  .setSslContext(SSLContextBuilder.create()
                                          .loadTrustMaterial(TrustAllStrategy.INSTANCE)
                                          .build())
                                  .setHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                  .build())
                          .build())
                  .build()) {
  
              final RequestConfig config = RequestConfig.custom()
                      .build();
              final HttpGet request = new HttpGet("/");
              request.addHeader("X-Novada-Render-Type","html"); 
              request.setConfig(config);
  
              System.out.println("Executing request " + request.getMethod() + " " + request.getUri() +
                      " via " + proxy + " headers: " + Arrays.toString(request.getHeaders()));
  
              httpclient.execute(target, request, response -> {
                  System.out.println("----------------------------------------");
                  System.out.println(request + "->" + new StatusLine(response));
                  EntityUtils.consume(response.getEntity());
                  return null;
              });
          }
      }
  }
                            
                        

                            
  using System;
  using System.Net;
  using System.Net.Http;
  using System.Threading.Tasks;
  
  namespace OxyApi
  {
      class Program
      {
          static async Task Main(string[] args)
          {
              var webProxy = new WebProxy
              {
                  Address = new Uri("unblock.novada.pro:7799"),
                  BypassProxyOnLocal = false,
                  UseDefaultCredentials = false,
  
                  Credentials = new NetworkCredential(
                  userName: "account-zone-unblock",
                  password: "password"
                  )
              };
  
              var httpClientHandler = new HttpClientHandler
              {
                  Proxy = webProxy,
              };
  
              // We recommend accepting our certificate instead of allowing insecure (http) traffic
              httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
              httpClientHandler.ServerCertificateCustomValidationCallback =
                  (httpRequestMessage, cert, cetChain, policyErrors) =>
                  {
                      return true;
                  };
  
  
              var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);
              
              // Add custom cookies
              client.DefaultRequestHeaders.Add("X-Novada-Render-Type", "html"); 
              Uri baseUri = new Uri("https://www.google.com");
              client.BaseAddress = baseUri;
  
              var requestMessage = new HttpRequestMessage(HttpMethod.Get, "");
  
              var response = await client.SendAsync(requestMessage);
              var contents = await response.Content.ReadAsStringAsync();
  
              Console.WriteLine(contents);
          }
      }
  }