Skip to content

primpvscrul

MIT 3 1 504
7.1 million (month) Jun 01 2024 1.2.2(2026-04-03 07:11:15 ago)
107 1 14 MIT
Nov 09 2016 26.6 thousand (month) 1.6.0(2024-07-19 19:50:00 ago)

Primp is a Python HTTP client that impersonates real web browsers by replicating their TLS fingerprints, HTTP/2 settings, and header ordering. It is a lightweight alternative to curl-cffi for bypassing TLS and HTTP fingerprinting-based bot detection.

Key features include:

  • Browser impersonation Can impersonate Chrome, Firefox, Safari, Edge, and OkHttp clients by replicating their exact TLS fingerprints (JA3/JA4), HTTP/2 frame settings, header ordering, and other connection-level characteristics.
  • HTTP/2 support Full HTTP/2 support with configurable settings that match real browser behavior.
  • Lightweight Smaller and simpler than curl-cffi while providing similar impersonation capabilities. Built on Rust for performance.
  • Familiar API Provides a requests-like API with Session support, making it easy to adopt for developers familiar with the Python requests library.
  • Proxy support HTTP and SOCKS5 proxy support with authentication.
  • Cookie management Automatic cookie handling across requests within a session.

Primp fills a similar niche to curl-cffi and hrequests — HTTP clients designed to avoid TLS/HTTP fingerprinting — but takes a Rust-powered approach for better performance. It is particularly useful when you need to bypass bot detection that relies on connection-level fingerprinting without using a full browser.

crul is a R library for sending HTTP requests and web scraping. It is designed to be simple and easy to use, while still providing powerful functionality for working with HTTP requests and scraping web pages.

One of the main features of crul is its intuitive and easy-to-use syntax for sending HTTP requests. It allows you to easily specify the HTTP method, headers, and body of a request, and also provides a simple way to handle the response.

crul also has the ability to handle different types of requests and responses, including GET, POST, PUT, DELETE, and PATCH. It also support for handling redirects, cookies, and authentication.

Another feature of crul is its support for web scraping. The library provides a simple and efficient way to extract data from web pages, using a syntax similar to that of the XML and httr libraries. It also allows to easily filter the extracted data based on a specific criteria.

crul also supports parallel scraping, which allows to make multiple requests at the same time, thus speeding up the scraping process.

In addition to these features, crul has a good compatibility with other R packages such as tidyverse and purrr which facilitates the manipulation of the data obtained after scraping.

Highlights


bypasstls-fingerprinthttp-fingerprinthttp2fast
http2uses-curlasync

Example Use


```python import primp # Create a session that impersonates Chrome session = primp.Session(impersonate="chrome_131") # Make requests - TLS fingerprint matches real Chrome response = session.get("https://example.com") print(response.status_code) print(response.text) # POST with JSON data response = session.post( "https://api.example.com/data", json={"key": "value"}, ) # With proxy session = primp.Session( impersonate="firefox_133", proxy="http://user:pass@proxy.example.com:8080", ) response = session.get("https://example.com") # Different browser impersonation profiles for browser in ["chrome_131", "firefox_133", "safari_18", "edge_131"]: session = primp.Session(impersonate=browser) resp = session.get("https://tls.peet.ws/api/all") print(f"{browser}: {resp.json()['ja3_hash']}") ```
```r library(crul) # Sending a GET request to a website response <- HttpClient$new("https://www.example.com")$get() # Sending a POST request to a website request_body <- list(param1 = "value1", param2 = "value2") response <- HttpClient$new("https://www.example.com")$post(body = request_body) # Extracting the status code and body of the response status_code <- response$status_code() body <- response$body() # crul also allows easy asynchronous requests: urls <- c("https://www.example1.com", "https://www.example2.com", "https://www.example3.com") # Creating a list of request objects from urls requests <- lapply(urls, function(url) { HttpClient$new(url)$get() }) # Sending the requests asynchronously responses <- async(requests) # Extracting the status code and body of the responses status_codes <- lapply(responses, function(response) response$status_code()) bodies <- lapply(responses, function(response) response$body()) ```

Alternatives / Similar


Was this page helpful?