What makes proxq notable?

1.2K downloads. Trust evidence available

How should proxq be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

proxq

Go, Redis-backed async HTTP proxy queue (built on asynq). POST any HTTP request (any method, any path, any body) to a configured upstream, get a job ID back instantly (202), a worker forwards it later, you poll GET /__jobs/{id} for status (queued/running/completed/failed) and GET /__jobs/{id}/content for the replayed upstream response (status/headers/body). DELETE /__jobs/{id} cancels. Path-prefix routing to multiple upstreams, per-upstream timeout/retries/pathFilter, optional response caching (memory or Redis LRU), automatic direct-proxy bypass for WebSocket/chunked/large-body requests. No built-in auth. Use when the user wants to turn a slow/unreliable backend into a fire-and-forget async API, decouple a client from upstream latency, relay webhooks with retries, or queue heavy uploads/processing jobs behind short-timeout reverse proxies.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.2k

Updated

Oct 11, 2026

Version

0.11.4

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.2K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.2K downloadsadoption · observed Oct 11, 2026
Latest release: 0.11.4release · observed Oct 10, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:proxq

Install using `clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:proxq` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/psyb0t/proxq before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-proxq/snapshot"

Documentation

CLAWHUB

147,111 characters of source documentation, loaded on request.

Extracted files

4 files captured from the source.

SKILL.md

---
name: proxq
description: Go, Redis-backed async HTTP proxy queue (built on asynq). POST any HTTP request (any method, any path, any body) to a configured upstream, get a job ID back instantly (202), a worker forwards it later, you poll GET /__jobs/{id} for status (queued/running/completed/failed) and GET /__jobs/{id}/content for the replayed upstream response (status/headers/body). DELETE /__jobs/{id} cancels. Path-prefix routing to multiple upstreams, per-upstream timeout/retries/pathFilter, optional response caching (memory or Redis LRU), automatic direct-proxy bypass for WebSocket/chunked/large-body requests. No built-in auth. Use when the user wants to turn a slow/unreliable backend into a fire-and-forget async API, decouple a client from upstream latency, relay webhooks with retries, or queue heavy uploads/processing jobs behind short-timeout reverse proxies.
homepage: https://github.com/psyb0t/docker-proxq
user-invocable: true
metadata:
  { "openclaw": { "emoji": "🦡", "primaryEnv": "PROXQ_URL", "requires": { "bins": ["curl", "docker"] } } }
permissions:
  network: "outbound HTTP to the configured PROXQ_URL (submit/poll/cancel job calls) — AND proxq itself makes arbitrary outbound HTTP requests to whatever upstream/URL you submit through it, on your behalf. That's an SSRF surface: only submit requests you intend proxq's configured upstreams to receive."
  shell: "curl + docker/docker-compose invocations shown in setup.md and this file (container lifecycle, request examples) — no other host access"
---

# proxq

The honey badger of HTTP proxies. POST a request, get a job ID back instantly, come back later for the goods. "I'll get back to you" as a service — every HTTP request becomes an async job in a Redis-backed queue (via [asynq](https://github.com/hibiken/asynq)).

For installation, configuration, and container setup, see [references/setup.md](references/setup.md).

## Security & safety

- **This is an SSRF surface by design.** proxq's whole job is to make outbound HTTP requests to an upstream on your behalf — that's not a bug, it's the feature. Anyone who can submit a job through proxq gets proxq's network position to reach whatever `upstreams[].url` is configured (and, via `directProxyMode`/prefix stripping, whatever path/query you tack onto it). Never point an upstream at internal/admin services you wouldn't otherwise expose, and never let untrusted callers choose the upstream prefix or URL.
- **No built-in authentication or authorization.** proxq ships with zero auth — no API key, no bearer token, no allowlist. Anyone who can reach `PROXQ_URL` can submit jobs, poll any job ID, and cancel any job ID (job IDs are UUIDv4 but there is no ownership check). Front it with a reverse proxy doing auth (basic auth, mTLS, an API gateway) or bind it to loopback/an internal network only — do not expose a bare proxq instance to the open internet.
- **Trusted upstreams only.** Configure `upstreams[].url` to point only at backends you control or

_meta.json

{
  "ownerId": "kn79dhvmpjng4rp2jjk8k0v5xx80ccbk",
  "slug": "proxq",
  "version": "0.11.4",
  "publishedAt": 1791645929937
}

references/setup.md

# proxq setup

## Quick start (docker compose)

```yaml
services:
  proxq:
    image: psyb0t/proxq
    ports:
      - "127.0.0.1:8080:8080"   # bind loopback-only; no built-in auth (see SKILL.md Security & safety)
    environment:
      PROXQ_CONFIG: /etc/proxq/config.yaml
    configs:
      - source: proxq_config
        target: /etc/proxq/config.yaml
    depends_on:
      - redis

  redis:
    image: redis:7-alpine
    restart: unless-stopped

configs:
  proxq_config:
    content: |
      listenAddress: "0.0.0.0:8080"
      redis:
        addr: "redis:6379"
      upstreams:
        - prefix: "/"
          url: "http://your-api:3000"
```

```bash
docker compose up -d
curl http://127.0.0.1:8080/__jobs/nonexistent-id   # 404, X-Proxq-Source: proxq → confirms it's up
```

## Docker run (config file mounted from host)

```bash
docker run -d \
  --name proxq \
  -p 127.0.0.1:8080:8080 \
  -e PROXQ_CONFIG=/etc/proxq/config.yaml \
  -v "$(pwd)/config.yaml:/etc/proxq/config.yaml:ro" \
  --link redis \
  psyb0t/proxq
```

Requires a reachable Redis instance (`redis:7-alpine` or any compatible server).

## Config resolution

Config path is resolved in this order: `--config` CLI flag → `PROXQ_CONFIG` env var → `config.yaml` in the current directory. Everything else lives inside the YAML file itself — there is no per-field env var override for the rest of the settings, so mount/generate the YAML.

| Env var / flag | Purpose |
|---|---|
| `--config <path>` | CLI flag, highest priority |
| `PROXQ_CONFIG` | Path to the YAML config file, read if `--config` is unset |

The published image runs the process as a fixed non-root user (`proxq`) baked into the image at build time — there is no `PUID`/`PGID` override.

## Config file reference (YAML)

### Global settings

| Field | Type | Default | Description |
|---|---|---|---|
| `listenAddress` | string | `127.0.0.1:8080` | HTTP server bind address |
| `redis.addr` | string | `127.0.0.1:6379` | Redis server address |
| `redis.username` | string | `""` | Redis ACL username. Empty uses the default user |
| `redis.password` | string | `""` | Redis password |
| `redis.db` | int | `0` | Redis database number |
| `queue` | string | `default` | asynq queue name |
| `concurrency` | int | `10` | Concurrent workers hitting upstream |
| `jobsPath` | string | `/__jobs` | Base path for the jobs API endpoints |
| `taskRetention` | duration | `1h` | How long completed/failed jobs stay in Redis before eviction |

Duration values use Go syntax: `30s`, `5m`, `1h`, `1h30m`.

### Upstreams (`upstreams[]`)

Routed by longest path-prefix match; the matched prefix is stripped before forwarding.

| Field | Type | Default | Description |
|---|---|---|---|
| `prefix` | string | **required** | URL path prefix for routing. Stripped before forwarding. |
| `url` | string | **required** | Upstream server URL. May include a path (e.g. `http://api:3000/v2`). |
| `timeout` | duration | `5m` | Per-upstream request timeout (overridable per-request via

skill-card.md

## Description:

Helps developers submit HTTP requests to a trusted proxq instance for asynchronous forwarding, then poll results or cancel jobs.

This skill is ready for commercial/non-commercial use.

## Publisher:

[psyb0t](https://clawhub.ai/user/psyb0t)

### License/Terms of Use:

MIT-0

## Use Case:

Developers and engineers use this skill to submit requests to a proxq instance, monitor queued work, retrieve upstream responses, and cancel their own jobs when needed.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: An internet-exposed proxq instance has no built-in authentication or job ownership checks.

Mitigation: Bind it to loopback or an internal network, require authentication or mTLS at the edge, and cancel only jobs you own.

Risk: Submitted requests can reach configured upstreams from the proxy's network position.

Mitigation: Configure only trusted upstreams and submit only requests intended for those services.

Risk: Unpinned container images can change between deployments.

Mitigation: Pin Docker images before production use.

## Reference(s):

- [proxq ClawHub release](https://clawhub.ai/psyb0t/skills/proxq)
- [proxq setup and configuration](references/setup.md)

## Skill Output:

**Output Type(s):** [Shell commands, Configuration guidance, Text]

**Output Format:** [Markdown with shell and YAML examples]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [Job IDs, status, and upstream responses are returned by the configured proxq instance.]

## Skill Version(s):

0.11.4 (source: ClawHub release evidence)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.