# Requizon vs Laravel Nightwatch

> Nightwatch monitors the whole application and groups outgoing requests by host. Requizon monitors only outgoing requests, down to the path and the failure.

Source: https://requizon.boring-observability.dev/vs/nightwatch
Section: Comparisons — Requizon
Updated: 2026-09-16

---

**Bottom line:** If you want one tool for the whole application, Nightwatch is that tool, and its outgoing requests page answers "which host is slow" with counts, 4xx and 5xx splits and a p95. Requizon goes further on that one question: it groups by API, host and path, tells a timeout from a 500 from a 200 with an error in the body, keeps the body of what failed, and never samples. It also keeps everything in your own database for a single payment. Plenty of teams will want both.

[Laravel Nightwatch](https://nightwatch.laravel.com) is Laravel's hosted monitoring service. You install its package, run its agent, and it sends requests, queries, jobs, exceptions, logs and outgoing HTTP requests to a dashboard run by Laravel. Outgoing requests are one page of it. Requizon only does outgoing requests, so this page compares Requizon with that one page, and it is worth saying at the start that the rest of Nightwatch has no counterpart in Requizon at all.

## One page of an APM, or a whole tool for one question

Nightwatch's strength is the trace. Every event belongs to the request, command or scheduled task that caused it, so a slow checkout page opens onto the queries, cache calls and outgoing requests inside it, in order. If your question is "why was this request slow", that is the view you want, and Requizon cannot give it to you.

Requizon starts from the other end. It files every call under the API it went to, then the host, then the path, and keeps hourly statistics for a year. Its question is "how has Stripe been behaving since Tuesday", asked of every dependency at once.

## At a glance

| For outgoing requests | Nightwatch | Requizon |
| --- | --- | --- |
| What else it monitors | The whole application | Nothing else |
| Where the data lives | Laravel's cloud, US or EU region | Your own MySQL database |
| Price | Free for 300k events a month, then plans from $20/mo | A [one-time purchase](https://requizon.boring-observability.dev#pricing) per app |
| Laravel versions | 10 to 13 | 12 and 13 |
| Grouping | Host | [API](https://requizon.boring-observability.dev/docs/naming-apis), host and [normalised path](https://requizon.boring-observability.dev/docs/paths) |
| Response time | Average and p95 | Average, with the three slowest members of each level charted |
| Status | Counts of 1xx–3xx, 4xx and 5xx | Each status code and failure type, charted over time |
| Calls that got no response | Not recorded as outgoing requests | `connection_error`, with the cause |
| A 200 with an error in the body | Counted as successful | [`application_error`](https://requizon.boring-observability.dev/docs/failure-detection), from your own callback |
| Bodies | Request and response sizes only | Response body of failed calls; [redacted](https://requizon.boring-observability.dev/docs/redaction) request parameters |
| Sampling | Follows the request, command or task that made the call | None |
| See the call inside its trace | Yes | No |
| Alerting | Performance thresholds, issue notifications to Slack and webhooks | None |
| History | 14 to 90 days, by plan | [14 days of calls, 365 days of hourly statistics](https://requizon.boring-observability.dev/docs/retention) |

## Where the records differ

### Calls that never got a response

Nightwatch's HTTP client middleware records a call when its response arrives. In laravel/nightwatch 1.30, the current release as we write this, a transfer that ends without a response adds nothing to the outgoing requests page: a timeout, a refused connection, a failed DNS lookup or a TLS error. The source marks recording those as a to-do, so this may change. Until it does, the `ConnectionException` can still reach Nightwatch as an exception, provided your code lets it be reported rather than catching it.

Requizon hooks Guzzle's `on_stats` callback, which fires for those transfers too. They are stored as `connection_error` with the cause, and they count against the API's success rate like any other failure.

### Errors inside a 200

Some APIs answer `200 OK` with `{"errorCode": 42}` in the body. Nightwatch records the status code, so those calls count as successful. Requizon lets you register one callback that reads the decoded body and returns a message when the call failed, and the call is then stored as an `application_error`. The callback only runs if you register it, since it means reading every successful body.

### Grouping below the host

Nightwatch's list is one row per host, and opening a host lists its individual requests with status and duration. Requizon adds two levels. Several hosts can be one named API (`api.stripe.com` and `files.stripe.com` as `stripe`), and each host breaks down into paths with IDs replaced, so `/v1/orders/8134/items` and every other order's equivalent share the row `/v1/orders/:id/items` and its chart.

### Sampling

Outgoing requests in Nightwatch have no sample rate of their own. They are kept when the request, command or scheduled task that made them is sampled, and Nightwatch's documentation recommends starting new applications at a request sample rate of `0.1` or lower. At that rate, the calls your web requests make are a one-in-ten sample. That is fine for spotting a slow host and less fine for "did every webhook to our partner go through". Requizon records every transfer, and it stays cheap at that volume because the dashboard reads hourly rollups rather than the raw rows.

## When Nightwatch is the better choice

- **You want one tool, not several.** Nightwatch covers exceptions, slow queries, jobs and outgoing requests together, correlated. Requizon is a second dashboard for one part of that.
- **You need to know which request made the call.** Requizon records the call, not its context. It cannot tell you that the slow Stripe call happened inside `POST /checkout`.
- **You want alerting.** Requizon has none. It is a dashboard you look at.
- **You would rather not host the data.** Requizon's tables live in your database and grow with your traffic, bounded by its pruning. Nightwatch stores nothing on your side.
- **You are on Laravel 10 or 11, or not on MySQL.** Requizon needs Laravel 12 or later and MySQL 8.0.20+ (or a compatible MariaDB) for its rollup query. Nightwatch has no database requirement in your app.

## What each costs, and where the data goes

Nightwatch bills by event, and every outgoing request is an event, alongside every query, cache call and job in the same traces. As of September 2026 the free plan includes 300,000 events a month with 14 days of history, Pro is $20 a month for 7.5 million events and 30 days, Team is $60 for 30 million and 60 days, and Business is $300 for 180 million and 90 days. Sampling and spending caps are how you keep that bill predictable, which is part of why sampling is the recommended default.

Requizon is a single payment per application, and it has no quota because there is nobody to send the data to. It writes to three tables in your database and serves its dashboard from your app. That matters most when the traffic itself is sensitive, for example calls to a payment or health data provider that your contracts do not let you forward to a third party.

## Running both

Nightwatch and Requizon both register global middleware on Laravel's HTTP client, neither modifies the request, and each records the same call into its own storage. A reasonable split is Nightwatch for the application and Requizon for the history of each dependency. Push Requizon's [Guzzle middleware](https://requizon.boring-observability.dev/docs/what-gets-recorded) onto any SDK client you have already given `Nightwatch::guzzleMiddleware()`, and both tools will see those calls as well.


## Common questions

### Does Laravel Nightwatch monitor outgoing HTTP requests?

Yes. Nightwatch captures calls made through Laravel's Http facade automatically, and Guzzle clients once you push Nightwatch::guzzleMiddleware() onto their handler stack. Its outgoing requests page groups calls by host domain and shows successful, 4xx and 5xx counts, the total, the average duration and the p95. Opening a host lists its individual requests with status code and duration.

### What does Requizon record that Nightwatch does not?

Requizon breaks traffic down below the host, into named APIs and normalised paths such as /v1/orders/:id, and charts each level. It classifies failures into connection errors (with the cause, such as a timeout or DNS failure), HTTP errors and application errors, the last being a 200 response your own callback marks as failed. It stores the response body of every failed call. Nightwatch's outgoing request record holds the method, URL, duration, request and response sizes and status code, with no bodies, and its dashboard groups by host.

### Does Nightwatch record outgoing requests that time out?

Not as outgoing requests, as of laravel/nightwatch 1.30. Its HTTP client middleware records a call when a response arrives, so a transfer that ends without one, such as a timeout, a refused connection or a failed DNS lookup, adds nothing to the host's counts. The ConnectionException can still reach Nightwatch as an exception if your code lets it be reported. Requizon records those transfers as connection_error rows with their cause.

### Does Nightwatch sample outgoing requests?

Indirectly. Outgoing requests have no sample rate of their own: they are captured when the request, command or scheduled task that made them is sampled. Nightwatch recommends starting new applications with a request sample rate of 0.1 or lower, and at that rate the outgoing requests made during web requests are a sample too. Requizon has no sampling and records every transfer.

### Can I run Requizon and Nightwatch together?

Yes. Both register global middleware on Laravel's HTTP client and neither changes the request, so each records the same call independently. Nightwatch shows you the call inside the web request or job that made it, and Requizon shows you the same call in the history of the API it went to.

### Where is the data stored?

Nightwatch is a fully managed service: the agent sends your events to Laravel's data centres in the US or EU, and Nightwatch does not offer self-hosting. Requizon writes to tables in your own MySQL database and serves its dashboard from your own application, so nothing leaves your servers.