Fresh Proxy Lists

List of fresh, working proxies (HTTP, HTTPS, SOCKS4 & SOCKS5) servers.

Updated at: Sun Dec 15 17:45:56 UTC 2024

Overview

Fresh Proxy Lists provides an up-to-date list of proxies across multiple formats and types. This repository is perfect for developers and security enthusiasts looking for reliable proxy lists.

Features

• Regular Updates: Updated automatically every day to ensure fresh and working proxies.
• Multiple Formats: Available in TXT, CSV, PHP, JSON, and XML.
• Various Types: Includes HTTP, HTTPS, SOCKS4, and SOCKS5 proxies.

Getting Started

Follow the instructions below to download the proxy lists.

Download by Type

HTTP

curl -sL https://vakhov.github.io/fresh-proxy-list/http.txt -o http.txt

HTTPS

curl -sL https://vakhov.github.io/fresh-proxy-list/https.txt -o https.txt

SOCKS4

curl -sL https://vakhov.github.io/fresh-proxy-list/socks4.txt -o socks4.txt

SOCKS5

curl -sL https://vakhov.github.io/fresh-proxy-list/socks5.txt -o socks5.txt

Download by Format

Supported formats: TXT | CSV | PHP | JSON | XML

Plain Text (TXT)

curl -sL https://vakhov.github.io/fresh-proxy-list/proxylist.txt -o proxylist.txt

CSV

curl -sL https://vakhov.github.io/fresh-proxy-list/proxylist.csv -o proxylist.csv

Serialized PHP Array

curl -sL https://vakhov.github.io/fresh-proxy-list/proxylist.phps -o proxylist.phps

JSON

curl -sL https://vakhov.github.io/fresh-proxy-list/proxylist.json -o proxylist.json

XML

curl -sL https://vakhov.github.io/fresh-proxy-list/proxylist.xml -o proxylist.xml

Usage Examples

Below are some examples of how you can use these proxy lists in different programming languages.

C# Example (using HttpClient)

using System;
using System.IO;
using System.Net.Http;
using System.Net;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string[] proxies = File.ReadAllLines("http.txt");
        string proxy = proxies[0];
        string[] proxyParts = proxy.Split(':');

        var httpClientHandler = new HttpClientHandler()
        {
            Proxy = new WebProxy(proxyParts[0], int.Parse(proxyParts[1])),
            UseProxy = true,
        };

        HttpClient client = new HttpClient(httpClientHandler);
        HttpResponseMessage response = await client.GetAsync("http://example.com");
        string content = await response.Content.ReadAsStringAsync();
        Console.WriteLine(content);
    }
}

Go Example

package main

import (
    "bufio"
    "fmt"
    "net/http"
    "net/url"
    "os"
    "strings"
)

func main() {
    file, err := os.Open("http.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    scanner.Scan()
    proxyLine := scanner.Text()
    proxyURL, err := url.Parse("http://" + proxyLine)
    if err != nil {
        panic(err)
    }

    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}
    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

Kotlin Example

import java.io.BufferedReader
import java.io.File
import java.net.HttpURLConnection
import java.net.InetSocketAddress
import java.net.Proxy
import java.net.URL

fun main() {
    val proxies = File("http.txt").readLines()
    val proxyParts = proxies[0].split(":")

    val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress(proxyParts[0], proxyParts[1].toInt()))
    val url = URL("http://example.com")
    val connection = url.openConnection(proxy) as HttpURLConnection

    connection.inputStream.bufferedReader().use(BufferedReader::readText).let {
        println(it)
    }
}

Swift Example (using URLSession)

import Foundation

if let proxyList = try? String(contentsOfFile: "http.txt") {
    let proxies = proxyList.components(separatedBy: "\n")
    let proxyParts = proxies[0].components(separatedBy: ":")

    let config = URLSessionConfiguration.default
    config.connectionProxyDictionary = [
        kCFNetworkProxiesHTTPEnable: true,
        kCFNetworkProxiesHTTPProxy: proxyParts[0],
        kCFNetworkProxiesHTTPPort: Int(proxyParts[1]) ?? 8080
    ] as [String : Any]

    let session = URLSession(configuration: config)
    let url = URL(string: "http://example.com")!

    let task = session.dataTask(with: url) { data, response, error in
        if let data = data, let responseString = String(data: data, encoding: .utf8) {
            print(responseString)
        }
    }
    task.resume()
}

Swift Example (using Alamofire)

import Alamofire

if let proxyList = try? String(contentsOfFile: "http.txt") {
    let proxies = proxyList.components(separatedBy: "\n")
    let proxyParts = proxies[0].components(separatedBy: ":")

    let sessionManager = Session.default
    sessionManager.sessionConfiguration.connectionProxyDictionary = [
        kCFNetworkProxiesHTTPEnable: true,
        kCFNetworkProxiesHTTPProxy: proxyParts[0],
        kCFNetworkProxiesHTTPPort: Int(proxyParts[1]) ?? 8080
    ]

    sessionManager.request("http://example.com").responseString { response in
        switch response.result {
        case .success(let value):
            print(value)
        case .failure(let error):
            print(error)
        }
    }
}

Python Example

import requests

with open('http.txt') as file:
    proxies = file.readlines()

proxy = proxies[0].strip()
response = requests.get('http://example.com', proxies={'http': proxy})
print(response.text)

JavaScript Example

const axios = require('axios');
const fs = require('fs');

fs.readFile('http.txt', 'utf8', (err, data) => {
    if (err) throw err;
    const proxies = data.split('\n');
    const proxy = proxies[0];

    axios.get('http://example.com', {
        proxy: {
            host: proxy.split(':')[0],
            port: proxy.split(':')[1]
        }
    })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
});

Bash Example

proxy=$(head -n 1 http.txt)
curl -x $proxy http://example.com

PHP Example

<?php
$proxies = file('http.txt', FILE_IGNORE_NEW_LINES);
$proxy = $proxies[0];

$context = stream_context_create([
    'http' => [
        'proxy' => 'tcp://' . $proxy,
        'request_fulluri' => true,
    ],
]);

$response = file_get_contents('http://example.com', false, $context);
echo $response;
?>

Ruby Example

require 'net/http'

proxies = File.readlines('http.txt')
proxy = proxies[0].strip.split(':')

uri = URI('http://example.com')
Net::HTTP.start(uri.host, uri.port, proxy[0], proxy[1].to_i) do |http|
  request = Net::HTTP::Get.new uri
  response = http.request request
  puts response.body
end

Java Example

import java.io.*;
import java.net.*;

public class ProxyExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("http.txt"));
        String proxyLine = reader.readLine();
        reader.close();
        
        String[] proxyParts = proxyLine.split(":");
        String proxyHost = proxyParts[0];
        int proxyPort = Integer.parseInt(proxyParts[1]);

        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
        URL url = new URL("http://example.com");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);

        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String inputLine;
        StringBuilder content = new StringBuilder();
        while ((inputLine = in.readLine()) != null) {
            content.append(inputLine);
        }
        in.close();

        System.out.println(content.toString());
    }
}

Contributing

We welcome contributions from the community! If you have any suggestions, bug reports, or pull requests, please feel free to submit them.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Disclaimer

These listings are provided for informational purposes only. Please use them for viewing purposes only. I do not encourage or support anything illegal or unlawful.