Laravel exception tracker

Exception tracking
for Laravel.

Laritor tracks exceptions and monitors performance in your Laravel app. Get an alert when an exception occurs, see the failing code, and follow the request or job’s events to understand why it happened.

Record only occurrences with exceptions, or monitor other issues and all application activity. Debug with in-app AI or connect your coding agent through Laritor MCP.

Free trial: 300K events · Unlimited apps and users

The exception, failing file, and occurrence history at a glanceView screenshot
Laritor exception tracker showing an ErrorException, its message, app/Jobs/GenerateSitemap.php line 51, total occurrences, and first and last seen dates
01

Know when something failsAlerts in the tools your team uses.

02

Understand the causeStack traces and the events behind them.

03

Work on a fix fasterIn-app AI and context for your coding agent.

Laravel error monitoring

An exception tells you
what broke. Context tells you why.

A Laravel exception tracker gives you a place to investigate errors reported by your app. Laritor shows the exception message, full stack trace, exact file and line, and previous occurrences. It also connects the error to the request, job, command, or scheduled task where it happened.

Laravel’s error logs are a useful starting point. With Laritor, you can follow the recorded queries, logs, and outbound requests around an exception, get notified through your team’s tools, and use that context to work on a fix.

Read the exception tracking guide

From alert to investigation

Fix exceptions in minutes.

Start with the alert. Follow the code and recorded events. Give your AI agent the details it needs to help.

  1. 01

    Receive an alert

    Learn when an exception occurs in your Laravel app. Open the alert to see what failed.

    Explore this step
  2. 02

    Find the failing code

    See the exact file and line, surrounding code, and full stack trace.

    Explore this step
  3. 03

    Follow the request or job

    Inspect the recorded queries, logs, and API calls that led to the exception.

    Explore this step
  4. 04

    Work on the fix with AI

    Use in-app recommendations, or give your coding agent the context through Laritor MCP.

    Explore this step

Exception alerts

Get notified
where you need to.

Know when your app throws an exception without keeping a dashboard open. Send alerts to a team channel, an inbox, or your issue tracker, then open the exception in Laritor to investigate.

Choose the applications, environments, and channels that matter. Configure production alerts separately from development activity.

Set up exception alerts

Bring the exception into your team’s conversation.

Send an exception alert to Slack with its class, message, application, environment, and failing file. Follow the link to investigate the full occurrence in Laritor.

A Laravel exception alert in SlackView screenshot
Slack notification from Laritor showing an exception message, application and environment, failing code location, code snippet, and a link to the exception

Stack traces and code previews

Go straight to
the line that failed.

Read the exception class and message, then inspect the exact file and line where it occurred. Laritor shows the surrounding code and full stack trace so you can follow the calls that reached the failing operation.

Explore exception details
The failing line and full stack trace, with application and vendor framesView screenshot
Laritor Laravel exception stack trace showing 38 frames, application and vendor frame controls, frame search, and highlighted PHP code at GenerateSitemap.php line 51

See the surrounding code

Read the lines around the failure. Check whether the code expected a value, an array key, or a successful response that was missing.

Follow the call stack

Search stack frames and inspect application or vendor code. Understand how execution reached the exception, rather than stopping at its message.

Connect it to one execution

Open an occurrence to inspect the specific request or job. The same exception can happen under different conditions, so investigate the run that matters.

The events behind an exception

Follow the entire
request or job journey.

A stack trace shows where code failed. The recorded event timeline helps explain what happened beforehand. Inspect queries, logs, API calls, and other related events in order, with their timings and available details.

For example, an unexpected API response can leave a value empty. Follow the outbound request and the code that used its response to understand the error at the failing line.

A recorded job timeline with database queries, logs, and an exceptionView screenshot
Laritor recorded job event timeline showing individual database queries, query durations, logs, N+1 query warnings, and an exception count
Related events you can inspect
  • Queries
  • Logs
  • Outbound requests
  • Cache
  • Jobs
  • Mail
  • Notifications
  • Feature flags
  • Custom events

Check database operations

Inspect the queries around a failure. Find the operation behind a database exception or an unexpected result used later in your code.

Follow external calls

Review recorded outbound requests when your app depends on a payment provider or another service. Use the available response details to investigate failures.

Add your own context

Record custom events for steps such as validating an order or importing a batch. Add the application details that make a failure easier to understand.

Record custom events

Context follows your recording and privacy settings. Exceptions-only mode keeps related events for occurrences with exceptions; it does not send all successful activity.

Web requests and background work

Track errors wherever
your Laravel code runs.

Failures happen beyond the browser. Use the same exception tracker to investigate reported errors from web requests, queue workers, console commands, and recurring tasks.

HTTP requests

Investigate errors behind a broken page, checkout, or API response. Open the recorded request and follow its events.

Explore request monitoring

Queued jobs

Find the exception behind an unsuccessful import, email, or report. Inspect the job execution and its related events.

Explore job monitoring

Artisan commands

Trace exceptions in console commands, maintenance scripts, and other work that runs outside a web request.

Explore command monitoring

Occurrence history and error trends

Find recurring errors.
Check what happens after a fix.

See how often an exception occurs and when it was first and last seen. Filter by date, exception class, or message to find relevant errors and decide what to investigate first.

After deploying a change, check for new occurrences when the affected code runs again. Open any remaining failures to see whether the cause has changed.

Inspect each time the exception happened.

See the exception’s first and last occurrence and how often it has happened. Open an individual occurrence to investigate the request, command, scheduled task, or job behind it.

Individual occurrences linked to their recorded job executionsView screenshot
Laritor exception occurrence history showing timestamps and links to individual GenerateSitemap queued job executions

AI-assisted Laravel debugging

Debug faster with
MCP Server and In-app AI.

Give AI the details of the actual failure: the exception, stack trace, and recorded events. Get recommendations in Laritor, or let your coding agent investigate those details alongside your application code.

Connect your agent to Laritor MCP

Get an explanation and a suggested fix.

Laritor’s in-app AI analyzes the exception and its recorded context to explain what may have caused it. Review the recommendations and example code alongside the stack trace before making a change.

AI recommendations for a database connection exceptionView screenshot
Laritor in-app AI explaining a SQLSTATE too many connections exception and recommending a different session driver to reduce database load

Use the agent you already work with. Connect tools such as Claude Code, Cursor, or Codex through MCP. Your agent retrieves the recorded context and works on the code through its own development workflow.

Choose your in-app AI provider. Each account includes 50 AI prompts per month. Connect your own provider when you need more usage. Review and test suggested changes before deployment. See AI provider settings →

Control what leaves your app

Concerned about
your data privacy?

Keep useful debugging context while protecting sensitive and personally identifiable information. Laritor’s Laravel client lets you customize and redact data before sending it.

Configure privacy and redaction

Remove sensitive fields

Redact passwords, access tokens, and other private values in strings and structured data. Define the fields and patterns your application should not send.

Anonymize user information

Customize recorded user identifiers, names, and email addresses. Keep the context you need to investigate without sending unnecessary personal information.

Choose the context you record

Control headers, session data, and request or response bodies through client settings. Request and response bodies are disabled by default.

Use Laritor how you want

Track only
what you care about.

You can use Laritor as a Laravel exception tracker without recording every successful request or job. Choose the activity you want to send. All three modes include the same Laritor features.

Most cost effective

Exceptions only

Record a request, job, command, or task only when it contains an exception. Keep its related events to understand the failure. Discard successful activity without exceptions.

For developers who mainly want a Laravel exception tracker.

Maximum value

Full observability

Record successful activity as well as problems. Monitor request times, queues, database queries, and other activity across your Laravel app.

For teams that want a full picture of application performance.

Related queries, logs, and other recorded events count toward usage in every mode. Recording fewer occurrences can reduce extra event charges.

Choose your recording mode

Exception tracking pricing

Pay for what you record.
Keep the context you need.

The price depends on the events you send. With exceptions-only recording, you send occurrences with exceptions and their related events, instead of paying to record all successful activity.

Estimate your monthly cost

Free trial

$0to try Laritor

  • 300K events
  • 14-day data retention
  • Try all three recording modes
  • Unlimited apps and users
Try for free

Pay as you go

$20/ month

  • 20 million events per month
  • $0.20 per extra 100K events
  • 30-day data retention
  • Unlimited apps, users, and alerts
Start tracking exceptions

Laravel package installation

Install in under 1 minute.
Choose what to record.

Install the Laravel client, connect your app, and choose exceptions-only recording. Set up alerts so your team knows when an exception needs attention.

Read the installation guide
  1. 01

    Create your Laritor application

    Create an account and add your application. Copy its ingest endpoint and backend key from Laritor’s setup instructions.

    Install the Laravel package
    composer require binarybuilds/laritor-client
  2. 02

    Add your connection settings

    Enable Laritor and replace the example values with your application’s credentials in your .env file.

    Environment settings
    LARITOR_ENABLED=true
    LARITOR_INGEST_ENDPOINT=your-ingest-url
    LARITOR_BACKEND_KEY=your-backend-key
  3. 03

    Choose exceptions-only recording

    Generate the exceptions-only filter. Then register the generated override in your AppServiceProvider’s register method, as shown below.

    Filter registration guide →
    Generate the recording filter
    php artisan make:laritor-filter exceptions-only
    AppServiceProvider.php · register()
    public function register(): void
    {
        $this->app->bind(
            \BinaryBuilds\LaritorClient\Override\LaritorOverride::class,
            \App\Laritor\LaritorDataFilter::class
        );
    }
  4. 04

    Sync your app and configure alerts

    Run the sync command after deployment. In Laritor, connect an alert integration and enable exception alerts for the application and environments you want to monitor.

    Alert configuration guide →
    Sync application configuration
    php artisan laritor:sync

I have tried Laritor in action on one of my projects, and it's really good. It gives observability of the whole Laravel project and various operations. Totally recommend!

Povilas KoropLaravel Daily

Common questions

Laravel exception tracking,
explained.

How recording, alerts, AI debugging, privacy, and billing work in Laritor.

What is a Laravel exception tracker?

A Laravel exception tracker collects exceptions from your application so you can see what failed, when it failed, and where it failed in your code. Laritor adds occurrence history, alerts, full stack traces, and related events from the recorded request, job, command, or scheduled task. You can use it for exception tracking alone or extend it to issue tracking and performance monitoring.

Can I use Laritor only for exception tracking?

Yes. Choose exceptions-only recording to send occurrences that contain an exception, along with their related events. Successful activity without exceptions is discarded. You still get stack traces, occurrence history, alerts, and AI debugging features without recording all application activity.

What is the difference between an exception and an occurrence?

An exception identifies an error, such as its class, message, and failing code location. An occurrence is an individual time that error happened. Laritor lets you inspect occurrence history and open the recorded request or job associated with a particular failure.

Does exceptions-only mode keep queries, logs, and API calls?

Yes. When a recorded request, job, command, or task contains an exception, Laritor keeps the related events permitted by your recording settings. These can include database queries, logs, outbound requests, cache operations, and custom events. That context helps explain the failure. The occurrence and its related events count toward your usage.

How is Laritor different from Laravel’s error logs?

Laravel can report exceptions through its configured logging channels. Laritor gives you a dedicated interface to investigate those exceptions, inspect full stack traces and surrounding code, review occurrence history, and follow recorded events from the affected request or job. It also connects exception alerts to your team’s tools and provides AI-assisted debugging.

Can Laritor track exceptions in queued jobs and Artisan commands?

Yes. Laritor tracks exceptions from recorded HTTP requests, queued jobs, Artisan commands, and scheduled tasks. From an exception occurrence, open the related execution to inspect its events. This helps investigate background failures as well as errors visible to users.

Can I see the exact file and line where an exception happened?

Yes. The exception details include the error message, class, failing file and line, full stack trace, and a code preview around the failing line. Search the stack frames and inspect application or vendor frames to follow the calls that led to the error.

How do I get alerts when a Laravel exception occurs?

Configure an integration in Laritor, then enable exception alerts for your application and choose the environments and channels you need. Laritor supports Slack, email lists, Microsoft Teams, Discord, Telegram, GitHub, Linear, and webhooks. GitHub and Linear integrations can create issues containing the exception details and a link to Laritor.

How can I tell whether an exception keeps happening?

Review its total occurrence count and first and last seen dates, then inspect individual occurrences. Use date and exception class or message filters to find relevant errors. After deploying a fix, check for new occurrences during the period when the affected code runs again.

Can AI help me debug a Laravel exception?

Laritor’s in-app AI provides explanations, recommendations, and example code based on the exception and recorded context. Alternatively, connect your coding agent through Laritor MCP so it can retrieve exception details and related events, then investigate them with your repository. Review and test the proposed change before deploying it. Each account includes 50 in-app AI prompts per month; you can also connect your own AI provider.

What does the Laritor MCP server provide to my coding agent?

Laritor MCP gives a connected agent access to recorded application data, including exception details, stack traces, and request or job event timelines. The agent can use this context with the code in your repository to understand a failure and work on a fix. Laritor’s data tools provide context; changes to your code happen through your coding agent’s own workflow.

Can I protect sensitive data and personally identifiable information?

Yes. Customize the Laravel client to redact sensitive strings and fields, anonymize authenticated user information, and control the context you record before it is sent to Laritor. Request and response bodies are disabled by default. Use the customization hooks to remove tokens, passwords, email addresses, or other data your application should not send.

How much does Laravel exception tracking with Laritor cost?

The free trial includes 300K events and 14-day retention. The paid plan starts at $20 per month with 20 million events and 30-day retention. Additional events cost $0.20 per 100K. All three recording modes have the same base price. In exceptions-only mode, you pay for the exception occurrences and related events you send, rather than all successful activity.

Does one exception occurrence count as one billable event?

An occurrence can include several events. For example, a recorded request with three queries, one log entry, and one exception uses six events when each is 2KB or less: the request, three queries, the log, and the exception. Larger events count in 2KB blocks. Your bill depends on the events and data sizes you send.

How do I add Laritor exception tracking to my Laravel app?

Create a Laritor application, install binarybuilds/laritor-client with Composer, and add the application’s connection settings to your environment. Generate an exceptions-only filter and register the generated override in your AppServiceProvider. Run php artisan laritor:sync after deployment, then configure exception alerts in Laritor. The installation and customization guides explain each step.

Can I monitor slow requests and failed jobs as well as exceptions?

Yes. Switch to issues-only recording to include detected problems such as failed jobs, failed requests, and slow operations. Choose full observability to also record successful activity for broader performance monitoring. All modes include Laritor features; the choice determines which activity your application sends.

Keep exploring

Guides for your next step.

Get started with Laritor

Understand your next exception.
Start working on the fix.

Get alerts, full stack traces, and the events behind your Laravel errors. Start with exceptions only and expand to issue tracking or performance monitoring when you need it.

Free trial: 300K events · Unlimited apps and users