Announcing Chaos Proxy API: Automate Network Chaos in CI/CD 🚀

Moving Beyond "Localhost" Testing

Until now, Debuggo has been a fantastic tool for manual testing. You spin up a proxy, connect your phone, and verify how your app handles a 503 error or high latency. It works great for ad-hoc debugging.

But manual testing doesn't scale.

You cannot ask your QA team to manually verify "Offline Mode" handling on every single Pull Request. You cannot manually check if your payment gateway handles double-clicks correctly before every deploy.

To build truly resilient apps, you need Continuous Chaos.

Today, we are launching the Chaos Proxy API. Now you can programmatically create proxies, configure chaos rules, and tear them down—all within your CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins).

Architecture: How it works in CI

The API gives you full control over the lifecycle of a Chaos Proxy directly from your pipeline scripts:

1. 
   Create: Spin up a fresh, isolated proxy instance on demand (POST /sessions).


2. 
   Configure: Apply chaos rules (latency, errors, body tampering) via JSON (PUT /rules).


3. 
   Certify: Download the CA certificate to install on Android Emulators or iOS Simulators (GET /certs).


4. 
   Test: Run your E2E suite (Playwright, Appium, Cypress) routing traffic through the proxy.


5. 
   Destroy: Clean up resources when the test finishes (DELETE /sessions).

Real-World Example: GitHub Actions

Here is a complete workflow. This script spins up a proxy, injects a 3-second latency to simulate a slow network, runs tests to ensure the UI handles "Rage Clicks" correctly, and then shuts everything down.

name: 🧪 Chaos E2E Tests



on: [push]



jobs:

  chaos-test:

    runs-on: ubuntu-latest

    steps:

      - uses: actions/checkout@v3



      # 1. Start the Proxy

      - name: 🚀 Start Debuggo Proxy

        id: start_proxy

        run: |

          RESPONSE=$(curl -s -X POST https://chaos-proxy.debuggo.app/api/v1/sessions \

            -H "Authorization: Bearer ${{ secrets.DEBUGGO_API_KEY }}")



          # Extract and save details to ENV

          echo "PROXY_ID=$(echo $RESPONSE | jq -r .id)" >> $GITHUB_ENV

          echo "PROXY_HOST=$(echo $RESPONSE | jq -r .host)" >> $GITHUB_ENV

          echo "PROXY_PORT=$(echo $RESPONSE | jq -r .port)" >> $GITHUB_ENV

          echo "PROXY_AUTH=$(echo $RESPONSE | jq -r .auth)" >> $GITHUB_ENV



      # 2. Configure Chaos (The "Bad 3G" Simulation)

      - name: 💣 Configure Chaos Rules

        run: |

          curl -X PUT https://chaos-proxy.debuggo.app/api/v1/sessions/$PROXY_ID/rules \

            -H "Authorization: Bearer ${{ secrets.DEBUGGO_API_KEY }}" \

            -H "Content-Type: application/json" \

            -d '{

              "rules": [

                {

                  "url_pattern": "*/api/checkout",

                  "delay": 3000,

                  "error_code": null

                }

              ]

            }'



      # 3. Run Tests

      - name: 🧪 Run Playwright Tests

        run: |

          # Route traffic through the authenticated proxy

          export HTTPS_PROXY="http://$PROXY_AUTH@$PROXY_HOST:$PROXY_PORT"

          npx playwright test



      # 4. Cleanup (Always run this, even if tests fail)

      - name: 🧹 Cleanup

        if: always()

        run: |

          curl -X DELETE https://chaos-proxy.debuggo.app/api/v1/sessions/$PROXY_ID \

            -H "Authorization: Bearer ${{ secrets.DEBUGGO_API_KEY }}"

API Reference

Use these endpoints to integrate Chaos Proxy into your custom scripts.

Authentication

Authenticate all requests by including your API Key in the header. You can generate a key in your Dashboard Settings.

Authorization: Bearer dbg_ci_YOUR_KEY

1. Start Proxy Session
   Creates a new isolated proxy container. Returns the host, port, and credentials.


2. Endpoint: POST /api/v1/sessions
   


3. Response:
   

{

  "id": "sess_abc123",

  "host": "proxy-us-east.debuggo.app",

  "port": 10245,

  "auth": "user:pass"

}

1. Configure Rules
   Updates the chaos logic in real-time. You can change rules mid-test (e.g., test success first, then inject failure).


2. Endpoint: PUT /api/v1/sessions/{session_id}/rules
   


3. Body Example:
   

{

  "rules": [

    {

      "url_pattern": "*/api/v1/checkout",

      "failure_rate": 100,

      "error_code": 503,

      "delay": 0

    },

    {

      "url_pattern": "*/api/v1/search",

      "delay": 2000

    }

  ]

}

1. Download CA Certificate
   Retrieves the Root CA certificate. Essential for automated setup of Android Emulators or iOS Simulators in CI.


2. Endpoint: GET /api/v1/certs/ca.pem


3. Usage:
   

curl -O https://chaos-proxy.debuggo.app/api/v1/certs/ca.pem

# Then install via adb

1. Stop Session
   Stops the proxy and releases the port.


2. Endpoint: DELETE /api/v1/sessions/{session_id}
   

Why automate Chaos?

1. 
   Catch Regressions in "Unhappy Paths" Developers often break error handling logic because they rarely see errors locally. Automating a 500 Error test ensures your "Something went wrong" screen never breaks.


2. 
   Validate Idempotency By injecting latency into your payment endpoints during CI, you can verify that your backend correctly handles duplicate requests (Rage Clicks) before they reach production.


3. 
   Native Mobile Testing Unlike Playwright’s built-in page.route (which only works in a browser context), Debuggo works at the system level. This allows you to test Native Android and iOS apps running in emulators within your CI pipeline.

Ready to break your build (on purpose)? Get your API Key.