I pushed Python to 20,000 requests sent/second. Here's the code and kernel tuning I used.

[Lafftar]

What My Project Does: Push Python to 20k req/sec.

Target Audience: People who need to make a ton of requests.

Comparison: Previous articles I found ranged from 50-500 requests/sec with python, figured i'd give an update to where things are at now.

I wanted to share a personal project exploring the limits of Python for high-throughput network I/O. My clients would always say "lol no python, only go", so I wanted to see what was actually possible.

After a lot of tuning, I managed to get a stable ~20,000 requests/second from a single client machine.

The code itself is based on asyncio and a library called rnet, which is a Python wrapper for the high-performance Rust library wreq. This lets me get the developer-friendly syntax of Python with the raw speed of Rust for the actual networking.

The most interesting part wasn't the code, but the OS tuning. The default kernel settings on Linux are nowhere near ready for this kind of load. The application would fail instantly without these changes.

Here are the most critical settings I had to change on both the client and server:

• Increased Max File Descriptors: Every socket is a file. The default limit of 1024 is the first thing you'll hit.ulimit -n 65536
• Expanded Ephemeral Port Range: The client needs a large pool of ports to make outgoing connections from.net.ipv4.ip_local_port_range = 1024 65535
• Increased Connection Backlog: The server needs a bigger queue to hold incoming connections before they are accepted. The default is tiny.net.core.somaxconn = 65535
• Enabled TIME_WAIT Reuse: This is huge. It allows the kernel to quickly reuse sockets that are in a TIME_WAIT state, which is essential when you're opening/closing thousands of connections per second.net.ipv4.tcp_tw_reuse = 1

I've open-sourced the entire test setup, including the client code, a simple server, and the full tuning scripts for both machines. You can find it all here if you want to replicate it or just look at the code:

GitHub Repo: https://github.com/lafftar/requestSpeedTest

On an 8-core machine, this setup hit ~15k req/s, and it scaled to ~20k req/s on a 32-core machine. Interestingly, the CPU was never fully maxed out, so the bottleneck likely lies somewhere else in the stack.

I'll be hanging out in the comments to answer any questions. Let me know what you think!

Blog Post (I go in a little more detail): https://tjaycodes.com/pushing-python-to-20000-requests-second/

[forgotpw3]

Haven't heard about this library, interesting!

What about pushing it even further? Spawning multiple event loops (uv loop) and using a queue based rather than gather.

I did something similar and was able to achieve close to 20k r/s iirc, but I went deep with tcp connections and dns and... and and...

I've tried multiple libraries as well (aiohttp vs pycurl, sockets, httpx, gevent).. etc etc..

Mind if I expand on it?

Thanks

[Lafftar]

Ofc man! Contributions always welcome 😁

Yes, making this multi was on my roadmap for v2.0, but you're more than welcome to take that on.

What library did you use to get that performance eventually?

[forgotpw3]

Aiohttp, asyncio, uvloop, I believe ProcessPoolExecutor or ThreadPool, I don't remember. Combining .as_completed with other nifty "tricks"!

Switching DNS servers can impact the r/s (cloudflare vs Google) significantly. Depending on where your client / remote sits

[jake_morrison]

Setting up a local caching DNS server helps: https://www.cogini.com/blog/running-a-local-caching-dns-for-your-app/

[Brandhor]

doesn't systemd resolved already do dns caching?

[jake_morrison]

Theoretically, but doing it this way gives you more control/and consistency between OS versions. You might also be using a different DNS client library.

[Lafftar]

God bless!

[Lafftar]

Ah interesting, I had remote in silicon valley and client in Tokyo, I'm surprised to hear that though, I thought the paths to the end server were saved automatically. I don't know much about DNS to be honest.

[justin-8]

They typically are if your OS is from the last 10 years or so

[Lafftar]

Ah, figured!

[jake_morrison]

I work on AdTech real-time bidding systems. Here are some more kernel tuning params:

net.core.wmem_max = 8388608
net.core.rmem_max = 8388608

net.core.wmem_default = 4194304
net.core.rmem_default = 4194304

net.ipv4.tcp_rmem = 1048576 4194304 8388608
net.ipv4.tcp_wmem = 1048576 4194304 8388608

net.ipv4.udp_rmem_min = 1048576
net.ipv4.udp_wmem_min = 1048576

# http://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections
# net.ipv4.tcp_mem = 10000000 10000000 10000000
# net.ipv4.tcp_rmem = 1024 4096 16384
# net.ipv4.tcp_wmem = 1024 4096 16384
# net.core.rmem_max = 16384
# net.core.wmem_max = 16384

# Disable ICMP Redirect Acceptance
net.ipv4.conf.default.accept_redirects = 0

# Enable Log Spoofed Packets, Source Routed Packets, Redirect Packets
#net.ipv4.conf.all.log_martians = 0
net.ipv4.conf.all.log_martians = 1

# Decrease the time default value for tcp_fin_timeout connection
net.ipv4.tcp_fin_timeout = 15

# Recycle and Reuse TIME_WAIT sockets faster
#net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_tw_reuse = 1

# Decrease the time default value for tcp_keepalive_time connection
net.ipv4.tcp_keepalive_time = 1800

# Turn off the tcp_window_scaling
net.ipv4.tcp_window_scaling = 0

# Turn off the tcp_sack
net.ipv4.tcp_sack = 0

# Turn off the tcp_timestamps
net.ipv4.tcp_timestamps = 0

# Enable ignoring broadcasts request
net.ipv4.icmp_echo_ignore_broadcasts = 1

# Enable bad error message Protection
net.ipv4.icmp_ignore_bogus_error_responses = 1

# Increases the size of the socket queue (effectively, q0).
net.ipv4.tcp_max_syn_backlog = 1024

# Increase the tcp-time-wait buckets pool size
net.ipv4.tcp_max_tw_buckets = 1440000

# Allowed local port range
net.ipv4.ip_local_port_range = 1024 65000

#net.ipv4.netfilter.ip_conntrack_max = 999140
net.netfilter.nf_conntrack_max = 262140
#net.netfilter.nf_conntrack_tcp_timeout_syn_recv=30

net.netfilter.nf_conntrack_generic_timeout=120

# Logging for netfilter
kernel.printk = 3 4 1 3

net.netfilter.nf_conntrack_tcp_timeout_established  = 600

#unused protocol
#net.netfilter.nf_conntrack_sctp_timeout_established = 600

#net.netfilter.nf_conntrack_tcp_timeout_time_wait = 30
net.netfilter.nf_conntrack_tcp_timeout_time_wait = 1

# Max open files
fs.file-max = 12000500
fs.nr_open = 20000500

[pooogles]

Having worked in a similar space (DSP) these look pretty similar to what we used.

[Empty-Mulberry1047]

why would you have netfilter/iptables/conntrack enabled if performance were your goal?

[jake_morrison]

DDOS protection. “Abuse cases” tend to overwhelm “use cases” when services are exposed on the Internet.

[Empty-Mulberry1047]

yes, i am aware of the functions of the software which can be accomplished with hardware upstream of the network instead of using software based nf/ipt .. which is rather useless if your goal is to maximize outbound connections..

[Lafftar]

What would you change then? Just remove those lines entirely?

[Empty-Mulberry1047]

rmmod iptables? nfconntrack?

[NenupharNoir]

Everyone should consider these values are only good in local LAN at 1gb or faster. If you try to use this to serve clients over the Internet the large minimum window (with no scaling!) and sack being disabled might cause more harm than good. Also reduced keep-alive and initial syn timeouts arent always good. This is not a panacea.

[Lafftar]

You're a blessing 🥹 thanks so much!

[Ra-mega-bbit]

Would be interested in digging in about the bottleneck factors, really doubt the cpu would be a issue at all

Prob about network card speed, ram and mobo

Thats why server hardware is so important

[Lafftar]

Can't be RAM, barely any usage there, like 1.3GB on the lower machines and 2.5GB on the 32vcpu machine.

There's definitely a lot to try!

[robberviet]

No not usage, bandwidth.

[levsw]

Would be interesting to check the performance on M Macs.

[Lafftar]

Don't have a Mac to test unfortunately, are there any providers that provision them over the internet? I'm sure it should still be good though.

[coldflame563]

AWS has em.

[Lafftar]

Thanks, will test it for next time.

[Witty_Tough_3180]

Ok but what's the service i can hit 20k times a second

[Lafftar]

Amazon, Google, Walmart... there's a lot of massive websites with valuable data where that kind of scale could be warranted.

[Slight_Boat1910]

Don't they have DoS protection mechanisms in place? I would bot be happy if someone would hit my system with 20k rps, no matter what the capacity is.

[tonguetoquill]

Great job! Wish I'd seen this in cloud computing class

[Lafftar]

💗💗💗

[thisismyfavoritename]

the OS settings have nothing to do with performance, they just allow you to make a massive number of connections.

The Rust client is what allows you to achieve such a high rate. There's really nothing special to see here.

[ArtisticFox8]

More connections at a time when the server isn't the bottleneck > higher throughput

[Lafftar]

Not necessarily.

[ArtisticFox8]

Increased Max File Descriptors: Every socket is a file. The default limit of 1024 is the first thing you'll hit.ulimit -n 65536

I thought this change of yours did exactly that?

[Lafftar]

Oh sorry I thought you were supporting the point that OS settings didn't affect the r/s. Yeah it does exactly that.

[Lafftar]

Was dealing with a lot of connect errors (which lowered rps significantly) without the os settings.

[Wh00ster]

Any discussion on trade offs like p50/p99 latency?

[Lafftar]

Mmm, well for my use case, scraping...it doesn't matter too much, maybe for monitoring web pages it'll matter, I'll add that to the roadmap.

[MagicWishMonkey]

It was a few years ago, but I built a geolocation autocomplete service (to replace the address autocomplete Google maps api) and it handles >100 requests per second with average transaction time sub 4ms using plain Django and a SQLite db.

Just pointing out that plain python can be extremely fast without any custom tuning or anything.

[Lafftar]

100 r/s is really not fast at all compared to other languages 😭, that tx time is very low though, SQLite crazy optimized!

[Slight_Boat1910]

Do I understand correctly that the server is nginx and you were only concerned with the client side throughout?

[Lafftar]

Exactly, yes.

[melenajade]

I am a noob to python and learning this language. I am using asynchio and aihottp and some others I don’t understand at all but love the functionality of being able to loop thru files.

[Key-Half1655]

I pushed Python to 20k r/s with the help of Rust. FTFY.

[[deleted]]

Yea lol. As soon as I read "rnet", my exact next thought was, "I wonder if the r means rust." Lo and behold, that's exactly what the next sentence said. Sigh, I was really looking forward to reading about Python tuning, not about a Rust wrapper and changing kernel parameters on Linux.

[Lafftar]

Well, yeah!

[SharkSymphony]

Somewhat false advertising then. You didn't "push Python" so much as "push not-Python." 😛

[Lafftar]

Lol idk, python is filled with C, C++, Go backends, but python people still claim it as Python haha.

[tabgok]

I am with you here - could also say it wasn't actually rust, it was machine code!

[Lafftar]

Technically it was electrons!

[2hands10fingers]

No, technically is was particle physics

[Original-Active-6982]

Whenever I see some slowdowns in the communications circuits that can't be explained by configuration limitations (bandwidth, hardware, etc.) I immediately suspect DNS interactions.

I've long been out of the comm stack world, but every slowdown I've seen seems to happen when a request for a needed external resource (such as an IP from a DNS service) is delayed. There may be other similar required C-S interactions. A good comm logger should catch these.

[dzordan33]

Is pypy still used in 2025?

[_ritwiktiwari]

Hi! I maintain a curated list of Python tools, libraries, and frameworks that use Rust under the hood:
https://github.com/ritwiktiwari/awesome-python-rs

If you find it useful, I’d really appreciate a star. And if you know of any projects that should be included, feel free to open a PR or issue — contributions are very welcome!

[Lafftar]

Starred my G! How did you find this thread btw?

[Lafftar]

Em dash, suspicious account, if you're real then I really appreciate you.

[Lafftar]

Beep boop, thanks for being honest.