diff --git a/CheckProxy.csproj b/CheckProxy.csproj
index 9a3020c..c775d0e 100644
--- a/CheckProxy.csproj
+++ b/CheckProxy.csproj
@@ -15,6 +15,7 @@
   <ItemGroup>
     <PackageReference Include="Spectre.Console" Version="0.45.0" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
 </Project>
diff --git a/Program.cs b/Program.cs
index dda05cf..5b6f02f 100644
--- a/Program.cs
+++ b/Program.cs
@@ -1,7 +1,5 @@
 using Spectre.Console;
 using System.Net;
-using System.Net.NetworkInformation;
-using System.Net.Sockets;
 using System.CommandLine;
 
 /// <summary>
@@ -53,21 +51,26 @@ public static async Task<int> Main(string[] args)
     /// <param name="timeout">The timeout in milliseconds for each check.</param>
     static async Task CheckSingleProxy(string proxyAddress, int timeout)
     {
-        if (IPEndPoint.TryParse(proxyAddress, out var proxyEndPoint))
+        if (IPEndPoint.TryParse(proxyAddress, out _))
         {
             var webProxy = new WebProxy(proxyAddress);
-            AnsiConsole.MarkupLine("Target: [bold]" + proxyAddress + "[/]");
-
-            var columns = new List<Markup>
-            {
-                new Markup("[bold]Ping Check[/]"),
-                new Markup("[bold]TCP Connection[/]"),
-                new Markup("[bold]HTTP Proxy Check[/]"),
-            };
-            AnsiConsole.Write(new Columns(columns));
-
-            var results = await RunChecksInParallel(webProxy, proxyEndPoint, timeout);
-            AnsiConsole.Write(new Columns(results.Select(r => new Markup(r.ToString()))));
+            var checker = new ProxyChecker(webProxy);
+            var proxyInfo = await checker.CheckProxyAsync();
+
+            var table = new Table();
+            table.AddColumn("Property");
+            table.AddColumn("Value");
+
+            table.AddRow("Address", proxyInfo.Address ?? "N/A");
+            table.AddRow("Type", proxyInfo.Type ?? "N/A");
+            table.AddRow("Anonymity", proxyInfo.Anonymity ?? "N/A");
+            table.AddRow("Country", proxyInfo.Country ?? "N/A");
+            table.AddRow("ASN", proxyInfo.Asn ?? "N/A");
+            table.AddRow("Outgoing IP", proxyInfo.OutgoingIp ?? "N/A");
+            table.AddRow("Alive", proxyInfo.IsAlive ? "[green]Yes[/]" : "[red]No[/]");
+            table.AddRow("Additional Headers", proxyInfo.AdditionalHeaders ?? "N/A");
+
+            AnsiConsole.Write(table);
         }
         else
         {
@@ -91,14 +94,14 @@ static async Task CheckProxiesFromFile(FileInfo file, int timeout)
         var proxies = await File.ReadAllLinesAsync(file.FullName);
         AnsiConsole.MarkupLine($"[yellow]Found {proxies.Length} proxies in {file.Name}. Starting checks...[/]");
 
-        var columns = new List<Markup>
-        {
-            new Markup("[bold]Proxy[/]"),
-            new Markup("[bold]Ping[/]"),
-            new Markup("[bold]TCP[/]"),
-            new Markup("[bold]HTTP[/]"),
-        };
-        AnsiConsole.Write(new Columns(columns));
+        var table = new Table();
+        table.AddColumn("Address");
+        table.AddColumn("Type");
+        table.AddColumn("Anonymity");
+        table.AddColumn("Country");
+        table.AddColumn("ASN");
+        table.AddColumn("Outgoing IP");
+        table.AddColumn("Alive");
 
         var tasks = new List<Task>();
         var semaphore = new SemaphoreSlim(10); // Limit to 10 concurrent checks
@@ -111,25 +114,25 @@ static async Task CheckProxiesFromFile(FileInfo file, int timeout)
             {
                 try
                 {
-                    if (IPEndPoint.TryParse(proxyAddress, out var proxyEndPoint))
+                    if (IPEndPoint.TryParse(proxyAddress, out _))
                     {
                         var webProxy = new WebProxy(proxyAddress);
-                        var results = await RunChecksInParallel(webProxy, proxyEndPoint, timeout);
-                        AnsiConsole.Write(new Columns(
-                            new Markup(proxyAddress),
-                            new Markup(results[0].ToString()),
-                            new Markup(results[1].ToString()),
-                            new Markup(results[2].ToString())
-                        ));
+                        var checker = new ProxyChecker(webProxy);
+                        var proxyInfo = await checker.CheckProxyAsync();
+
+                        table.AddRow(
+                            proxyInfo.Address ?? "N/A",
+                            proxyInfo.Type ?? "N/A",
+                            proxyInfo.Anonymity ?? "N/A",
+                            proxyInfo.Country ?? "N/A",
+                            proxyInfo.Asn ?? "N/A",
+                            proxyInfo.OutgoingIp ?? "N/A",
+                            proxyInfo.IsAlive ? "[green]Yes[/]" : "[red]No[/]"
+                        );
                     }
                     else
                     {
-                        AnsiConsole.Write(new Columns(
-                            new Markup(proxyAddress),
-                            new Markup("[red]Invalid[/]"),
-                            new Markup("[red]Invalid[/]"),
-                            new Markup("[red]Invalid[/]")
-                        ));
+                        table.AddRow(proxyAddress, "[red]Invalid[/]", "[red]Invalid[/]", "[red]Invalid[/]", "[red]Invalid[/]", "[red]Invalid[/]", "[red]No[/]");
                     }
                 }
                 finally
@@ -140,118 +143,7 @@ static async Task CheckProxiesFromFile(FileInfo file, int timeout)
         }
 
         await Task.WhenAll(tasks);
+        AnsiConsole.Write(table);
         AnsiConsole.MarkupLine("[green]All proxy checks complete.[/]");
     }
-
-    /// <summary>
-    /// Runs a series of checks for a given proxy in parallel.
-    /// </summary>
-    /// <param name="wp">The WebProxy object for the proxy.</param>
-    /// <param name="proxyEp">The IPEndPoint for the proxy.</param>
-    /// <param name="timeout">The timeout in milliseconds for each check.</param>
-    /// <returns>A boolean array indicating the result of each check.</returns>
-    static async Task<bool[]> RunChecksInParallel(WebProxy wp, IPEndPoint proxyEp, int timeout)
-    {
-        var pingCheckTask = PingCheckAsync(proxyEp.Address.ToString(), timeout);
-        var tcpConnectionTask = TcpConnectionCheckAsync(wp.Address.Host, wp.Address.Port, timeout);
-        var httpProxyCheckTask = HttpProxyCheckAsync(wp, timeout);
-
-        await Task.WhenAll(
-            pingCheckTask,
-            tcpConnectionTask,
-            httpProxyCheckTask);
-
-        return new[]
-        {
-            pingCheckTask.Result,
-            tcpConnectionTask.Result,
-            httpProxyCheckTask.Result,
-        };
-    }
-
-    /// <summary>
-    /// Performs an HTTP GET request through the proxy to check its functionality.
-    /// </summary>
-    /// <param name="wp">The WebProxy to use for the request.</param>
-    /// <param name="timeout">The timeout in milliseconds for the request.</param>
-    /// <returns>True if the request is successful; otherwise, false.</returns>
-    static async Task<bool> HttpProxyCheckAsync(WebProxy wp, int timeout)
-    {
-        var handler = new HttpClientHandler
-        {
-            Proxy = wp,
-            UseProxy = true,
-        };
-
-        using var client = new HttpClient(handler);
-        client.Timeout = TimeSpan.FromMilliseconds(timeout);
-
-        try
-        {
-            using var response = await client.GetAsync("http://www.google.com/generate_204");
-            return response.IsSuccessStatusCode;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    /// <summary>
-    /// Pings the specified address to check for reachability.
-    /// </summary>
-    /// <param name="address">The IP address or hostname to ping.</param>
-    /// <param name="timeout">The timeout in milliseconds for the ping.</param>
-    /// <returns>True if the ping is successful; otherwise, false.</returns>
-    static async Task<bool> PingCheckAsync(string address, int timeout)
-    {
-        using var ping = new Ping();
-        try
-        {
-            var reply = await ping.SendPingAsync(address, timeout);
-            return reply?.Status == IPStatus.Success;
-        }
-        catch (PingException)
-        {
-            return false;
-        }
-    }
-
-    /// <summary>
-    /// Attempts to open a TCP socket to the specified host and port.
-    /// </summary>
-    /// <param name="host">The target host.</param>
-    /// <param name="port">The target port.</param>
-    /// <param name="timeout">The timeout in milliseconds for the connection attempt.</param>
-    /// <returns>True if the connection is successful; otherwise, false.</returns>
-    static async Task<bool> TcpConnectionCheckAsync(string host, int port, int timeout)
-    {
-        using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
-        try
-        {
-            var connectTask = socket.ConnectAsync(host, port);
-            var timeoutTask = Task.Delay(TimeSpan.FromMilliseconds(timeout));
-
-            var completedTask = await Task.WhenAny(connectTask, timeoutTask);
-
-            if (completedTask == timeoutTask)
-            {
-                return false;
-            }
-
-            await connectTask;
-            return socket.Connected;
-        }
-        catch
-        {
-            return false;
-        }
-        finally
-        {
-            if (socket.Connected)
-            {
-                socket.Disconnect(false);
-            }
-        }
-    }
-}
\ No newline at end of file
+}
diff --git a/ProxyChecker.cs b/ProxyChecker.cs
new file mode 100644
index 0000000..91fc3b0
--- /dev/null
+++ b/ProxyChecker.cs
@@ -0,0 +1,223 @@
+using Newtonsoft.Json;
+using System.Net;
+using System.Net.Http.Headers;
+
+/// <summary>
+/// A class to check the validity of a proxy server.
+/// </summary>
+public class ProxyChecker
+{
+    private readonly HttpClient _httpClient;
+    private readonly WebProxy _proxy;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ProxyChecker"/> class.
+    /// </summary>
+    /// <param name="proxy">The proxy to use for the checks.</param>
+    public ProxyChecker(WebProxy proxy)
+    {
+        _proxy = proxy;
+        var handler = new HttpClientHandler
+        {
+            Proxy = proxy,
+            UseProxy = true,
+        };
+
+        _httpClient = new HttpClient(handler);
+        _httpClient.Timeout = TimeSpan.FromMilliseconds(5000);
+    }
+
+    /// <summary>
+    /// Checks the proxy and returns a <see cref="ProxyInfo"/> object with the results.
+    /// </summary>
+    /// <returns>A <see cref="ProxyInfo"/> object with the results of the check.</returns>
+    public async Task<ProxyInfo> CheckProxyAsync()
+    {
+        var proxyInfo = new ProxyInfo
+        {
+            Address = _proxy.Address.ToString(),
+            IsAlive = false,
+        };
+
+        try
+        {
+            var response = await _httpClient.GetStringAsync("http://httpbin.org/headers");
+            var headers = JsonConvert.DeserializeObject<HttpBinHeaders>(response);
+
+            var publicIpAddress = headers.Origin;
+            var headerDictionary = headers.Headers;
+
+            proxyInfo.IsAlive = true;
+            proxyInfo.OutgoingIp = publicIpAddress;
+
+            var ipInfo = await GetIpInfoAsync(publicIpAddress);
+            if (ipInfo != null)
+            {
+                proxyInfo.Country = ipInfo.Country;
+                proxyInfo.Asn = ipInfo.Asn;
+            }
+
+            proxyInfo.Type = await GetProxyTypeAsync();
+            proxyInfo.Anonymity = GetAnonymity(publicIpAddress, headerDictionary);
+            proxyInfo.AdditionalHeaders = string.Join(", ", headerDictionary.Keys);
+        }
+        catch
+        {
+            // Ignore exceptions
+        }
+
+        return proxyInfo;
+    }
+
+    /// <summary>
+    /// Gets the public IP address of the system.
+    /// </summary>
+    /// <param name="useProxy">Whether to use the proxy to get the public IP address.</param>
+    /// <returns>The public IP address of the system.</returns>
+    private async Task<string> GetPublicIpAddressAsync(bool useProxy)
+    {
+        try
+        {
+            var httpClient = useProxy ? _httpClient : new HttpClient();
+            var response = await httpClient.GetStringAsync("https://api.ipify.org");
+            return response.Trim();
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets the geolocation and ASN information for the specified IP address.
+    /// </summary>
+    /// <param name="ipAddress">The IP address to get the information for.</param>
+    /// <returns>A <see cref="IpInfo"/> object with the geolocation and ASN information.</returns>
+    private async Task<IpInfo> GetIpInfoAsync(string ipAddress)
+    {
+        try
+        {
+            var response = await new HttpClient().GetStringAsync($"http://ip-api.com/json/{ipAddress}");
+            return JsonConvert.DeserializeObject<IpInfo>(response);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets the proxy type.
+    /// </summary>
+    /// <returns>The proxy type.</returns>
+    private async Task<string> GetProxyTypeAsync()
+    {
+        if (await IsSocks5ProxyAsync())
+        {
+            return "SOCKS5";
+        }
+
+        if (await IsHttpsProxyAsync())
+        {
+            return "HTTPS";
+        }
+
+        return "HTTP";
+    }
+
+    /// <summary>
+    /// Checks if the proxy is a SOCKS5 proxy.
+    /// </summary>
+    /// <returns>True if the proxy is a SOCKS5 proxy; otherwise, false.</returns>
+    private async Task<bool> IsSocks5ProxyAsync()
+    {
+        try
+        {
+            var socket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
+            await socket.ConnectAsync(_proxy.Address.Host, _proxy.Address.Port);
+            var buffer = new byte[] { 5, 1, 0 };
+            await socket.SendAsync(buffer, System.Net.Sockets.SocketFlags.None);
+            var response = new byte[2];
+            await socket.ReceiveAsync(response, System.Net.Sockets.SocketFlags.None);
+            return response[0] == 5 && response[1] == 0;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Checks if the proxy is an HTTPS proxy.
+    /// </summary>
+    /// <returns>True if the proxy is an HTTPS proxy; otherwise, false.</returns>
+    private async Task<bool> IsHttpsProxyAsync()
+    {
+        try
+        {
+            var response = await _httpClient.GetAsync("https://www.google.com");
+            return response.IsSuccessStatusCode;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Gets the anonymity level of the proxy.
+    /// </summary>
+    /// <param name="publicIpAddress">The public IP address of the system.</param>
+    /// <param name="headers">The headers from the proxy.</param>
+    /// <returns>The anonymity level of the proxy.</returns>
+    private string GetAnonymity(string publicIpAddress, Dictionary<string, string> headers)
+    {
+        if (headers.ContainsKey("X-Forwarded-For") || headers.ContainsKey("Via"))
+        {
+            var forwardedFor = headers.ContainsKey("X-Forwarded-For") ? headers["X-Forwarded-For"] : "";
+            if (forwardedFor.Contains(publicIpAddress))
+            {
+                return "Transparent";
+            }
+            return "Anonymous";
+        }
+
+        return "Elite";
+    }
+}
+
+/// <summary>
+/// Represents the headers returned by httpbin.org/headers.
+/// </summary>
+public class HttpBinHeaders
+{
+    /// <summary>
+    /// Gets or sets the origin IP address.
+    /// </summary>
+    [JsonProperty("origin")]
+    public string Origin { get; set; }
+
+    /// <summary>
+    /// Gets or sets the headers.
+    /// </summary>
+    [JsonProperty("headers")]
+    public Dictionary<string, string> Headers { get; set; }
+}
+
+/// <summary>
+/// Represents the geolocation and ASN information for an IP address.
+/// </summary>
+public class IpInfo
+{
+    /// <summary>
+    /// Gets or sets the country of the IP address.
+    /// </summary>
+    [JsonProperty("country")]
+    public string Country { get; set; }
+
+    /// <summary>
+    /// Gets or sets the Autonomous System Number (ASN) of the IP address.
+    /// </summary>
+    [JsonProperty("as")]
+    public string Asn { get; set; }
+}
diff --git a/ProxyInfo.cs b/ProxyInfo.cs
new file mode 100644
index 0000000..69e51fa
--- /dev/null
+++ b/ProxyInfo.cs
@@ -0,0 +1,46 @@
+/// <summary>
+/// Represents the information about a proxy server.
+/// </summary>
+public class ProxyInfo
+{
+    /// <summary>
+    /// Gets or sets the proxy address.
+    /// </summary>
+    public string Address { get; set; }
+
+    /// <summary>
+    /// Gets or sets the proxy type (e.g., HTTP, HTTPS, SOCKS5).
+    /// </summary>
+    public string Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the anonymity level (e.g., Elite, Anonymous, Transparent).
+    /// </summary>
+    public string Anonymity { get; set; }
+
+    /// <summary>
+    /// Gets or sets the country of the proxy.
+    /// </summary>
+    public string Country { get; set; }
+
+    /// <summary>
+    /// Gets or sets the Autonomous System Number (ASN) of the proxy.
+    /// </summary>
+    public string Asn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the outgoing IP address of the proxy.
+    /// </summary>
+    public string OutgoingIp { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the proxy is alive.
+    /// </summary>
+    public bool IsAlive { get; set; }
+
+    /// <summary>
+    summary>
+    /// Gets or sets any additional headers added by the proxy.
+    /// </summary>
+    public string AdditionalHeaders { get; set; }
+}