primpvshttr
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.
The aim of httr is to provide a wrapper for the curl package, customised to the demands of modern web APIs.
Key features:
- Functions for the most important http verbs: GET(), HEAD(), PATCH(), PUT(), DELETE() and POST().
- Automatic connection sharing across requests to the same website (by default, curl handles are managed automatically), cookies are maintained across requests, and a up-to-date root-level SSL certificate store is used.
- Requests return a standard reponse object that captures the http status line, headers and body, along with other useful information.
- Response content is available with content() as a raw vector (as = "raw"), a character vector (as = "text"), or parsed into an R object (as = "parsed"), currently for html, xml, json, png and jpeg.
- You can convert http errors into R errors with stop_for_status().
- Config functions make it easier to modify the request in common ways: set_cookies(), add_headers(), authenticate(), use_proxy(), verbose(), timeout(), content_type(), accept(), progress().
- Support for OAuth 1.0 and 2.0 with oauth1.0_token() and oauth2.0_token(). The demo directory has eight OAuth demos: four for 1.0 (twitter, vimeo, withings and yahoo) and four for 2.0 (facebook, github, google, linkedin). OAuth credentials are automatically cached within a project.
Highlights
bypasstls-fingerprinthttp-fingerprinthttp2fast
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(httr)
# GET requests:
resp <- GET("http://httpbin.org/get")
status_code(resp) # status code
headers(resp) # headers
str(content(resp)) # body
# POST requests:
# Form encoded
resp <- POST(url, body = body, encode = "form")
# Multipart encoded
resp <- POST(url, body = body, encode = "multipart")
# JSON encoded
resp <- POST(url, body = body, encode = "json")
# setting cookies:
resp <- GET("http://httpbin.org/cookies", set_cookies("MeWant" = "cookies"))
content(r)$cookies # get response cookies
```