Open-source API proxy
Speed, reliability and observability. Less code.
HARP is an open-source HTTP proxy for your remote APIs, running alongside your applications. It improves the performances, reliability and observability of your internal and external services by instrumenting external HTTP calls.
You focus on delivering your business value, HARP takes care of caching, circuit breaking and recording your API calls.
Get started
One line, and HARP runs
With uv:
uvx harp-proxy@0.12.0 server --example sqlite --example proxy:httpbin
With a container:
docker run --init -it --rm -p 4000-4100:4000-4100 makersquad/harp-proxy:0.12.0 server
The image is amd64 only for now: on ARM, Apple Silicon included, use uvx.
Stay informed
Low volume, no spam, unsubscribe anytime.
Batteries included
Comes bundled with the usual API consumer needs
API proxy
Your external API requests and responses go through the proxy, with round-robin pools, fallback pools, connection retries and timeouts.
Read the docsHTTP cache
Responses are cached as RFC 9111 allows, and pattern-based rules can override the upstream's caching policy.
Read the docsDashboard
The dashboard shows aggregated metrics about your transactions: performance, counts and errors, over the last 24 hours or the time range you pick.
Read the docsTraffic history
Transactions are recorded for inspection in the dashboard, with the headers and bodies of requests and responses. Recording is best-effort: under load, HARP sheds detail rather than slowing traffic down.
Read the docsCircuit breaker
Once enabled, it protects your systems from cascading failures by taking failing remotes out of the pool and back in when they recover, using a liveness algorithm and optional health check probes.
Read the docsFlexible storage
From zero-configuration built-in SQLite storage for development to PostgreSQL in production, with an optional Redis content-addressable store for headers and bodies.
Read the docs
You can read the features guide to have an exhaustive glance at HARP's features.
Clean API exchanges
Communications you actually understand
API-related logic is bound to the target, not to each consumer: set it once in HARP, and every application benefits. Although we love Italian food, we prefer spaghetti not to run on our servers: HARP turns the tangle into a service map.
- Simple.
- One map of which applications call which APIs, instead of a tangle of direct connections.
- Observable.
- Every call goes through one route: the logs, metrics and recorded transactions are in one place.
- Manageable.
- Change how an API is called in one place, and every consumer follows.
- Smart.
- Caching, circuit breaking and transaction recording are built-in, and rules rewrite requests and responses: implemented once, not in each consumer. Don't repeat yourself.
Less code. Cache and failover logic in each application:
cache = {}
def get_product(id):
if id in cache:
return cache[id]
for url in API_URLS:
try:
r = httpx.get(f"{url}/products/{id}")
r.raise_for_status()
cache[id] = r.json()
return cache[id]
except httpx.HTTPError:
continue
raise RuntimeError("API unavailable")Less code. With HARP, responses are cached and a failing URL is taken out of the pool, with no code in the application:
def get_product(id):
return httpx.get(f"{API_URL}/products/{id}").json()See it in action
The built-in dashboard gives you an at-a-glance overview of your system's health, and a detailed, searchable log of the API transactions it records.
Free and open-source forever
HARP is free and open-source and will stay so. Get started in minutes, or reach out. Hire the team behind HARP for your API projects: it directly funds HARP and Makersquad's other open-source work. Enterprise support is available too.