# APXY > APXY is a desktop HTTP/HTTPS proxy for debugging, mocking, replaying, and analyzing network traffic. Last updated: 2026-08-21 ## Definition APXY is a local proxy for developers and teams who need to see what actually went over the wire. It captures HTTP and HTTPS traffic, exposes it in a CLI and browser-based Web UI, and helps users inspect requests, mock endpoints, replay traffic, and compare results after a fix. ## Best fit APXY is best for: - Debugging API failures that depend on the exact request or response - Mocking live endpoints so frontend and QA can keep moving - Replaying captured traffic after a code change - Comparing old and new responses side by side - AI-assisted debugging workflows where the model needs direct network evidence APXY is less relevant when: - You only need a simple one-off HTTP client - You do not need capture, replay, mocking, or traffic inspection ## Core pages - [Home](https://apxy.dev/) - [Blog](https://apxy.dev/blog) - [Templates](https://apxy.dev/templates) - [Examples](https://apxy.dev/examples) - [For Claude Code](https://apxy.dev/for/claude-code) - [For Cursor](https://apxy.dev/for/cursor) - [For Codex](https://apxy.dev/for/codex) - [For GitHub Copilot](https://apxy.dev/for/copilot) - [For Aider](https://apxy.dev/for/aider) - [For Continue](https://apxy.dev/for/continue) - [For Bolt](https://apxy.dev/for/bolt) - [APXY vs Charles Proxy](https://apxy.dev/compare/charles-proxy) - [APXY vs mitmproxy](https://apxy.dev/compare/mitmproxy) - [APXY vs Proxyman](https://apxy.dev/compare/proxyman) - [APXY vs Fiddler](https://apxy.dev/compare/fiddler) - [APXY vs Wireshark](https://apxy.dev/compare/wireshark) - [APXY vs Postman](https://apxy.dev/compare/postman) - [APXY vs HTTPie](https://apxy.dev/compare/httpie) - [Share Pack: Stripe checkout 422 after agent-generated patch](https://apxy.dev/share/stripe-checkout-422) - [Share Pack: OpenAI integration mocked for frontend development](https://apxy.dev/share/openai-mock-frontend) - [License and pricing](https://apxy.dev/license) - [Terms](https://apxy.dev/terms) - [Privacy](https://apxy.dev/privacy) - [Refund policy](https://apxy.dev/refund) ## Templates - [Stripe Mock Kit](https://apxy.dev/templates): Mock payment responses for checkout and billing flows - [GitHub API Mock Kit](https://apxy.dev/templates): Mock repository, user, and issue responses - [OpenAI Mock Kit](https://apxy.dev/templates): Mock LLM responses for frontend and agent testing ## Example workflows - [Basic Debugging](https://apxy.dev/examples): Capture traffic, inspect failures, and export a reproducible request - [API Mocking](https://apxy.dev/examples): Return stable responses from a live endpoint during development - [AI Agent Workflow](https://apxy.dev/examples): Give an AI coding tool request and response evidence for diagnosis ## Workflow summary 1. Start APXY locally. 2. Route your app traffic through the proxy. 3. Capture the failing request. 4. Inspect the request and response. 5. Mock, replay, or diff traffic as needed. 6. Re-run the request after a fix to verify the change. ## Pricing APXY offers a free tier and paid one-time licenses. Pricing details are published at [https://apxy.dev/license](https://apxy.dev/license). ## Blog articles - [How to Debug API Calls Made by Cursor](https://apxy.dev/blog/debug-api-calls-cursor-agent): Cursor writes code that calls APIs. When those calls fail, you can't debug what you can't see. This tutorial shows the exact workflow for capturing, inspecting, diffing, and replaying real API traffic from Cursor-generated code. - [Why Your AI Coding Agent Needs Network Visibility](https://apxy.dev/blog/why-your-ai-coding-agent-needs-network-visibility): AI coding agents are excellent at reading code. They cannot see the network. That gap is where most agent-assisted debugging sessions get stuck. Here is how to close it. - [What is API Mocking? A Developer's Guide](https://apxy.dev/blog/what-is-api-mocking): API mocking lets you simulate a real API without calling it. This guide explains what it is, why developers use it, when to mock vs when not to, and how to get started in under five minutes. - [The Real Cost of Flaky API Tests](https://apxy.dev/blog/the-real-cost-of-flaky-api-tests): A test that sometimes passes and sometimes fails is not a test -- it is noise. Here is what flaky API tests actually cost your team, and what to do about it. - [HTTP Status Codes Explained for API Developers](https://apxy.dev/blog/http-status-codes-explained): A practical reference to HTTP status codes for developers who build and debug APIs. What each code means, when APIs return it, and how to respond to it in your code. - [How to Mock a REST API in 5 Minutes with APXY](https://apxy.dev/blog/how-to-mock-a-rest-api-in-5-minutes): Create a fully functional mock REST API in under five minutes. No code, no config files, no server to maintain. One command to install, one command to add a rule. - [How to Debug a Failing API Call with APXY](https://apxy.dev/blog/how-to-debug-a-failing-api-call-with-apxy): A step-by-step walkthrough of the capture-inspect-replay loop. Learn how to track down a failing HTTP request, understand exactly why it failed, and prove your fix worked. - [From Postman to Proxy: When API Testing Needs Network Evidence](https://apxy.dev/blog/from-postman-to-proxy): Postman is great for constructing requests manually. It does not tell you what your application actually sent. When the bug is between your code and the network, you need a proxy. - [Debugging Webhooks Locally with APXY](https://apxy.dev/blog/debugging-webhooks-locally): Webhooks are notoriously hard to debug locally. APXY lets you intercept incoming webhook payloads, inspect them in real time, replay them without retriggering the source, and mock the endpoint for automated testing. - [How to Capture HTTPS Traffic from Cursor, Claude Code, and AI Coding Agents](https://apxy.dev/blog/capturing-https-traffic-from-cursor-and-ai-agents): AI coding agents make real API calls behind the scenes. Here is how to route Cursor, Claude Code, and other AI tools through APXY so you can see exactly what they are sending and receiving. - [APXY vs mitmproxy: When You Need More Than Interception](https://apxy.dev/blog/apxy-vs-mitmproxy-when-you-need-mocking-too): mitmproxy is one of the best open-source tools for HTTPS interception. But it stops there. If you also need mocking, a Web UI, or a workflow built for AI-assisted development, the tool gap becomes real. - [Token Optimization: Fitting API Traffic into Your AI Agent's Context Window](https://apxy.dev/blog/token-optimization-shrinking-api-traffic-for-ai-agent-context): Raw HTTP traffic is verbose. A single request-response pair can consume thousands of tokens. APXY's output formats compress traffic by 60–90% while keeping the information your agent actually needs to diagnose issues. - [How to Debug API Errors in CI/CD Pipelines with APXY](https://apxy.dev/blog/debug-api-errors-in-ci-cd-pipelines): API test failures in CI are notoriously hard to debug. You cannot reproduce the environment locally, logs are incomplete, and re-running the pipeline costs time. Running APXY alongside your test suite captures the exact traffic that caused the failure. - [How to Validate API Contracts with OpenAPI and APXY](https://apxy.dev/blog/validate-api-contracts-with-openapi-and-apxy): Import an OpenAPI spec into APXY and validate your live traffic against it. Find requests your code sends that don't match the spec — before they become production bugs. - [Dynamic API Responses: Scripting with JavaScript in APXY](https://apxy.dev/blog/scripting-api-responses-with-javascript-in-apxy): Static mock rules return the same response every time. When you need to inject dynamic data, modify responses conditionally, or simulate real API behavior like rate limiting, APXY's JavaScript scripting engine handles it. - [Why Local-First API Tools Are Winning](https://apxy.dev/blog/why-local-first-api-tools-are-winning): A wave of developers is moving away from cloud-hosted API tools. Pricing changes, data sovereignty concerns, and the rise of CLI-native workflows are driving a shift toward tools that live on your machine and sync through Git. - [Record and Replay API Traffic for Regression Testing with APXY](https://apxy.dev/blog/record-and-replay-api-traffic-for-regression-testing): Record real API traffic once, convert it to mock rules, and replay those exact responses against future code changes. Catch regressions before they reach production without maintaining a live test environment. ## Source - [GitHub repository](https://github.com/apxydev/apxy)