# How to Implement Sweet Alert Laravel for User Feedback After Form Submissions

> Learn how to implement Sweet Alert in Laravel for effective user feedback after form submissions. Utilize Laravel's redirect responses and Blade to display polished alerts.

- Repository: [Laravel/framework](https://github.com/laravel/framework)
- Tags: how-to-guide
- Published: 2026-02-19

---

**Flash structured alert data from your controller using Laravel's `with()` method on `RedirectResponse`, then render that data in your Blade layout with `Swal.fire()` to display polished feedback after form submissions.**

Sweet Alert Laravel integration provides an elegant way to notify users after form submissions without complex JavaScript logic. The `laravel/framework` repository offers a robust flash data mechanism through the `RedirectResponse` class and session storage that pairs perfectly with SweetAlert2's API, allowing you to trigger beautiful modals from server-side logic.

## How Laravel's Flash Data Mechanism Works

Laravel's feedback loop relies on **HTTP redirects combined with session flash data**. When a controller processes a form submission, it typically returns a redirect response with attached flash data using the `with()` method. This data persists only for the next request, making it ideal for transient UI messages.

### The RedirectResponse with() Method

In [`src/Illuminate/Http/RedirectResponse.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Http/RedirectResponse.php), the `with()` method attaches key-value pairs to the session's flash storage:

```php
public function with($key, $value = null)
{
    $key = is_array($key) ? $key : [$key => $value];

    foreach ($key as $k => $v) {
        $this->session->flash($k, $v);
    }

    return $this;
}

```

When you call `return redirect()->route('posts.index')->with('swal', [...])`, this method flashes the data to the session.

### Session Store Flash Implementation

The actual flash storage occurs in [`src/Illuminate/Session/Store.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Session/Store.php). The `flash()` method writes data into the `_flash.new` bucket:

```php
public function flash($key, $value)
{
    $this->put($key, $value);

    $this->push('_flash.new', $key);
}

```

After the next request, Laravel moves keys from `_flash.new` to `_flash.old`, then clears the old data, ensuring your Sweet Alert data disappears after being displayed.

## Sweet Alert Laravel Implementation Steps

### Step 1: Flash Data from Your Controller

Structure your flash data as an array with SweetAlert2-compatible options. In your controller method:

```php
public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|max:255',
        'body'  => 'required',
    ]);

    Post::create($validated);

    return redirect()
        ->route('posts.index')
        ->with('swal', [
            'icon'    => 'success',
            'title'   => 'Post created!',
            'text'    => 'Your new post has been saved successfully.',
            'confirmButtonText' => 'Great!'
        ]);
}

```

### Step 2: Create the Global Blade Handler

Add the SweetAlert2 CDN to your main layout file and include the flash data handler:

```blade
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@yield('title', 'My App')</title>
    <!-- SweetAlert2 -->
    <script src="https://cdn.jsdelivr.net/npm/sweetalert2@11"></script>
</head>
<body>
    @yield('content')

    @if (session('swal'))
        <script>
            const swalConfig = @json(session('swal'));
            Swal.fire(swalConfig);
        </script>
    @endif
</body>
</html>

```

The `@json` Blade directive safely converts the PHP array into a JavaScript object, preventing XSS vulnerabilities.

### Step 3: Handle Validation Errors with SweetAlert

Leverage the `ShareErrorsFromSession` middleware (located in [`src/Illuminate/View/Middleware/ShareErrorsFromSession.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/View/Middleware/ShareErrorsFromSession.php)) which automatically shares validation errors with all views via the `$errors` variable:

```blade
@if ($errors->any())
    <script>
        Swal.fire({
            icon: 'error',
            title: 'Validation failed',
            html: `{!! implode('<br>', $errors->all()) !!}`,
            confirmButtonColor: '#d33'
        });
    </script>
@endif

```

Place this immediately after the SweetAlert CDN inclusion to catch validation errors on form pages.

## Reusable Sweet Alert Laravel Component

For cleaner templates, create a dedicated Blade component at [`resources/views/components/swal.blade.php`](https://github.com/laravel/framework/blob/main/resources/views/components/swal.blade.php):

```blade
@if (session('swal'))
    <script>
        Swal.fire(@json(session('swal')));
    </script>
@endif

```

Then include it anywhere in your layout:

```blade
<body>
    @yield('content')
    
    <x-swal />
</body>

```

This approach keeps your layout clean and makes the Sweet Alert functionality reusable across multiple templates.

## Key Laravel Source Files Involved

Understanding the core implementation helps debug flash data issues. These files from the `laravel/framework` repository power the Sweet Alert Laravel integration:

| File | Role | Location |
|------|------|----------|
| [`RedirectResponse.php`](https://github.com/laravel/framework/blob/main/RedirectResponse.php) | Implements the `with()` method that flashes data to the session during redirects. | [`src/Illuminate/Http/RedirectResponse.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Http/RedirectResponse.php) |
| [`Store.php`](https://github.com/laravel/framework/blob/main/Store.php) | Contains the `flash()` method that writes data to `_flash.new` and manages the flash lifecycle. | [`src/Illuminate/Session/Store.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Session/Store.php) |
| [`ShareErrorsFromSession.php`](https://github.com/laravel/framework/blob/main/ShareErrorsFromSession.php) | Middleware that automatically exposes validation errors to views via the `$errors` variable. | [`src/Illuminate/View/Middleware/ShareErrorsFromSession.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/View/Middleware/ShareErrorsFromSession.php) |
| [`Validator.php`](https://github.com/laravel/framework/blob/main/Validator.php) | Performs validation logic and throws `ValidationException` that populates the session error bag. | [`src/Illuminate/Validation/Validator.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Validation/Validator.php) |

These components ensure that when you call `return redirect()->with('swal', [...])`, the data survives the redirect and appears in your next view's session.

## Summary

- **Flash structured arrays** from your controller using `redirect()->with('swal', [...])` to pass SweetAlert2 configuration options through the session.
- **Leverage core Laravel components**: `RedirectResponse::with()` in [`src/Illuminate/Http/RedirectResponse.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Http/RedirectResponse.php) and `Session\Store::flash()` in [`src/Illuminate/Session/Store.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Session/Store.php) handle persisting data across redirects.
- **Render safely** in Blade using `@json(session('swal'))` to prevent XSS vulnerabilities when passing PHP arrays to JavaScript.
- **Handle validation errors** automatically via the `ShareErrorsFromSession` middleware, which exposes `$errors` to views for SweetAlert error modals.
- **Create reusable components** by extracting the SweetAlert logic into a Blade component (`<x-swal />`) for cleaner layouts.

## Frequently Asked Questions

### How do I pass SweetAlert data from a Laravel controller?

Use the `with()` method on your redirect response to flash an array of SweetAlert2 options to the session. For example: `return redirect()->route('home')->with('swal', ['icon' => 'success', 'title' => 'Saved!'])`. The `RedirectResponse::with()` method in [`src/Illuminate/Http/RedirectResponse.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Http/RedirectResponse.php) handles storing this data via the session's `flash()` method.

### Can I use SweetAlert for Laravel validation errors?

Yes. The `ShareErrorsFromSession` middleware automatically shares validation errors with all views via the `$errors` variable. In your Blade template, check `@if ($errors->any())` and trigger `Swal.fire()` with `icon: 'error'` and the error messages in the `html` property. This works because the `Validator` class in [`src/Illuminate/Validation/Validator.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Validation/Validator.php) throws a `ValidationException` that populates the session error bag.

### Is it safe to pass session data directly to SweetAlert's JavaScript?

Yes, if you use Laravel's `@json()` Blade directive. This directive safely converts PHP arrays to JSON while escaping characters to prevent XSS attacks. Never use `{!! !!}` or raw PHP echo to output session data directly into JavaScript contexts. The `@json(session('swal'))` approach ensures that even if malicious data somehow enters the session, it cannot execute arbitrary JavaScript.

### What is the difference between using `with()` and `session()->flash()`?

Both achieve the same result, but `with()` is specifically designed for redirect responses. When you call `return redirect()->with('key', 'value')`, Laravel internally calls `session()->flash()` after setting up the redirect. The `with()` method is defined in [`src/Illuminate/Http/RedirectResponse.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Http/RedirectResponse.php) and provides a fluent interface for attaching flash data to redirects, while `session()->flash()` is the underlying mechanism in [`src/Illuminate/Session/Store.php`](https://github.com/laravel/framework/blob/main/src/Illuminate/Session/Store.php) that writes to the `_flash.new` array.