Laravel Google Tag Manager

https://github.com/spatie/laravel-googletagmanager
Admin
Laravel Google Tag Manager is a package that provides easy integration of Google Tag Manager into...
Tokens:8,100
Snippets:56
Trust Score:10
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Example Google Tag Manager Configuration

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

An example configuration for the spatie/laravel-googletagmanager package, demonstrating how to set a specific GTM ID, enable scripts only in production, and configure a custom domain for a GTM server container.

```php
return [
    'id' => 'GTM-XXXXXX',
    'enabled' => env('APP_ENV') === 'production',
    'sessionKey' => '_googleTagManager',
    // Base domain used in your GTM server container
    'domain' => 'gtm.yourdomain.com',
];
```

--------------------------------

### Install and Configure Laravel Google Tag Manager

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Installs the package via Composer and publishes its configuration file. The configuration allows setting the Google Tag Manager container ID, enabling/disabling the service, defining a session key, and specifying the domain for GTM. This is a prerequisite for using the package's functionalities.

```bash
composer require spatie/laravel-googletagmanager
php artisan vendor:publish --provider="Spatie\GoogleTagManager\GoogleTagManagerServiceProvider" --tag="config"
```

--------------------------------

### Install Google Tag Manager Package for Laravel

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Installs the spatie/laravel-googletagmanager package using Composer. This is the primary step to integrate Google Tag Manager functionalities into your Laravel application.

```bash
composer require spatie/laravel-googletagmanager
```

--------------------------------

### E-commerce Checkout Step Tracking in PHP

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Implement tracking for the first step of the e-commerce checkout process using Google Tag Manager in PHP. This example sets the 'pageType' to 'cart' and pushes e-commerce checkout details, including product information, to the dataLayer.

```php
// app/Http/Controllers/CartController.php (continued)
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

    public function index()
    {
        $cart = Cart::current();

        GoogleTagManager::set('pageType', 'cart');
        GoogleTagManager::set([
            'ecommerce' => [
                'checkout' => [
                    'actionField' => ['step' => 1],
                    'products' => $cart->items->map(fn($item) => [
                        'name' => $item->product->name,
                        'id' => $item->product->id,
                        'price' => $item->price,
                        'quantity' => $item->quantity,
                    ])->toArray()
                ]
            ]
        ]);

        return view('cart.index', compact('cart'));
    }
}
```

--------------------------------

### Advanced E-commerce Add to Cart Tracking in PHP

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Track 'addToCart' events with detailed product information using Google Tag Manager in PHP. This example demonstrates how to push e-commerce data, including product name, ID, price, brand, category, and quantity, to the dataLayer when a product is added to the cart.

```php
// app/Http/Controllers/CartController.php
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;
use Illuminate\Http\Request;

class CartController extends Controller
{
    public function add(Request $request, $productId)
    {
        $product = Product::findOrFail($productId);
        $quantity = $request->input('quantity', 1);

        Cart::add($product, $quantity);

        // Track add to cart event
        GoogleTagManager::flashPush([
            'event' => 'addToCart',
            'ecommerce' => [
                'add' => [
                    'products' => [[
                        'name' => $product->name,
                        'id' => $product->id,
                        'price' => $product->price,
                        'brand' => $product->brand,
                        'category' => $product->category,
                        'quantity' => $quantity,
                    ]]
                ]
            ]
        ]);

        return redirect()->back()->with('success', 'Product added to cart');
    }
}
```

--------------------------------

### Retrieve the Google Tag Manager DataLayer Instance in Laravel

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Shows how to get the current Google Tag Manager DataLayer instance using the facade, allowing direct manipulation or inspection of the DataLayer's contents.

```php
$dataLayer = GoogleTagManager::getDataLayer();
```

--------------------------------

### Retrieve and Manage Google Tag Manager ID and State in Laravel

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Provides examples of retrieving the Google Tag Manager ID, checking if script rendering is enabled, and programmatically enabling or disabling script rendering.

```php
// Retrieve your Google Tag Manager id
$id = GoogleTagManager::id(); // GTM-XXXXXX

// Check whether script rendering is enabled
$enabled = GoogleTagManager::isEnabled(); // true|false

// Enable and disable script rendering
GoogleTagManager::enable();
GoogleTagManager::disable();
```

--------------------------------

### Create and Render DataLayer Instance in PHP

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Demonstrates the standalone usage of the `SpatieGoogleTagManagerDataLayer` class. It allows creating a DataLayer instance, setting variables with dot notation, and rendering it as JSON.

```php
$dataLayer = new SpatieGoogleTagManagerDataLayer();
$dataLayer->set('ecommerce.click.products', $products->toJson());
echo $dataLayer->toJson(); // {"ecommerce":{"click":{"products":"..."}}}
```

--------------------------------

### Publish Google Tag Manager Configuration Files

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Publishes the configuration files for the spatie/laravel-googletagmanager package using the Artisan command. This allows customization of settings like the GTM ID and script rendering.

```bash
php artisan vendor:publish --provider="Spatie\GoogleTagManager\GoogleTagManagerServiceProvider" --tag="config"
```

--------------------------------

### Render DataLayer Push Script for Events

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This HTML snippet demonstrates how to render JavaScript to push events to the dataLayer after the page has loaded. It uses an event listener to trigger the push when the page is ready.

```html
<!-- Rendered in <body> after content -->
<script>
    function gtmPush() {
        window.dataLayer.push({"event":"user_login","method":"email","userId":456});
    }
    addEventListener("load", gtmPush);
</script>
```

--------------------------------

### Publish Google Tag Manager View Files

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Publishes the view files for the spatie/laravel-googletagmanager package. This is optional and generally not recommended unless specific view modifications are required, to maintain compatibility with future package updates.

```bash
php artisan vendor:publish --provider="Spatie\GoogleTagManager\GoogleTagManagerServiceProvider" --tag="views"
```

--------------------------------

### Rendered DataLayer Output in HTML Head

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Illustrates the expected HTML output generated by the `spatie/laravel-googletagmanager` package after setting dataLayer values. This script, typically placed within the `<head>` section of an HTML page, initializes the `dataLayer` array and pushes the configured tracking data as a JSON object, making it accessible to Google Tag Manager on the client side.

```html
<!-- Rendered output in <head> -->
<script>
    window.dataLayer = window.dataLayer || [];
    window.dataLayer.push({
        "pageType": "productDetail",
        "productId": 123,
        "ecommerce": {
            "detail": {
                "products": [{
                    "name": "Example Product",
                    "id": 123,
                    "price": 29.99,
                    "brand": "Example Brand",
                    "category": "Electronics"
                }]
            }
        },
        "user": {
            "id": 456,
            "tier": "premium"
        }
    });
</script>
```

--------------------------------

### Define Custom Macros for Tracking Patterns (PHP)

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This snippet shows how to create custom macros for the GoogleTagManager facade to encapsulate common tracking logic. It defines macros for 'productImpression' and 'trackPurchase', which can then be called from controllers to simplify event tracking. These macros help in maintaining consistency and reusability of tracking code.

```php
<?php
// app/Providers/AppServiceProvider.php
use Illuminate\Support\ServiceProvider;
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        // Macro for ecommerce product impressions
        GoogleTagManager::macro('productImpression', function ($product, $list = 'Search Results') {
            GoogleTagManager::set('ecommerce', [
                'currencyCode' => 'USD',
                'impressions' => [[
                    'name' => $product->name,
                    'id' => $product->id,
                    'price' => $product->price,
                    'brand' => $product->brand,
                    'category' => $product->category,
                    'list' => $list,
                    'position' => $product->position ?? 1,
                ]]
            ]);
        });

        // Macro for purchase tracking
        GoogleTagManager::macro('trackPurchase', function ($order) {
            GoogleTagManager::set('ecommerce', [
                'purchase' => [
                    'actionField' => [
                        'id' => $order->id,
                        'affiliation' => 'Online Store',
                        'revenue' => $order->total,
                        'tax' => $order->tax,
                        'shipping' => $order->shipping,
                        'coupon' => $order->coupon_code,
                    ],
                    'products' => $order->items->map(fn($item) => [
                        'name' => $item->product->name,
                        'id' => $item->product->id,
                        'price' => $item->price,
                        'quantity' => $item->quantity,
                        'category' => $item->product->category,
                    ])->toArray()
                ]
            ]);
        });
    }
}

```

--------------------------------

### Using DataLayer Class Directly in PHP

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This PHP code shows how to instantiate and manipulate the DataLayer class directly for custom implementations. It covers setting nested data, converting to JSON or array, accessing the main GoogleTagManager dataLayer, and clearing the data.

```php
use Spatie\GoogleTagManager\DataLayer;
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

// Create standalone DataLayer instance
$dataLayer = new DataLayer();
$dataLayer->set('product.name', 'Example Product');
$dataLayer->set('product.price', 29.99);

// Convert to JSON
echo $dataLayer->toJson();
// Output: {"product":{"name":"Example Product","price":29.99}}

// Convert to array
$array = $dataLayer->toArray();
// Output: ['product' => ['name' => 'Example Product', 'price' => 29.99]]

// Access the main GoogleTagManager's DataLayer
$mainDataLayer = GoogleTagManager::getDataLayer();
$currentData = $mainDataLayer->toArray();

// Clear all data
$dataLayer->clear();
```

--------------------------------

### Configure Google Tag Manager Settings

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Default configuration settings for the spatie/laravel-googletagmanager package. This includes the Google Tag Manager ID, script rendering enablement, session key for flash data, and the script domain.

```php
return [

    /*
     * The Google Tag Manager id, should be a code that looks something like "gtm-xxxx".
     */
    'id' => '',
    
    /*
     * Enable or disable script rendering. Useful for local development.
     */
    'enabled' => true,
    
     /*
     * The key under which data is saved to the session with flash.
     */
    'sessionKey' => '_googleTagManager',

     /*
     * Configures the Google Tag Manager script domain.
     * Modify this value only if you're using "Google Tag Manage: Web Container" client
     * to serve gtm.js for your web container. Else, keep the default value.
     */
    'domain' => 'www.googletagmanager.com',
];
```

--------------------------------

### Push Events After Page Load in Laravel

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This snippet illustrates how to push events to the dataLayer after the initial page load in Laravel using GoogleTagManager::push(). It's suitable for tracking user actions like logins or sign-ups that occur dynamically.

```php
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class AuthController extends Controller
{
    public function login(Request $request)
    {
        $credentials = $request->validate([
            'email' => 'required|email',
            'password' => 'required',
        ]);

        if (Auth::attempt($credentials)) {
            // Push event that fires on page load via addEventListener
            GoogleTagManager::push([
                'event' => 'user_login',
                'method' => 'email',
                'userId' => auth()->id(),
            ]);

            return redirect()->intended('dashboard');
        }

        return back()->withErrors(['email' => 'Invalid credentials']);
    }

    public function oauthCallback()
    {
        // Handle OAuth authentication
        $user = $this->handleOAuthCallback();

        if ($user->wasRecentlyCreated) {
            // Push multiple events - order matters
            GoogleTagManager::flashPush(['event' => 'sign_up', 'method' => 'OAuth']);
        }
        GoogleTagManager::flashPush(['event' => 'login', 'method' => 'OAuth']);

        return redirect()->intended();
    }
}
```

--------------------------------

### Render Fleshed DataLayer in HTML

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This HTML snippet shows how data flushed using GoogleTagManager::flash() in PHP is rendered in the browser's dataLayer after a redirect. It initializes the dataLayer and pushes the flashed variables.

```html
<!-- After redirect, rendered output includes flashed data -->
<script>
    window.dataLayer = window.dataLayer || [];
    window.dataLayer.push({
        "pageType": "contact",
        "event": "form_submission",
        "formType": "contact",
        "conversionValue": 100,
        "user": {
            "action": "contacted",
            "timestamp": "2025-12-13T10:30:00+00:00"
        }
    });
</script>
```

--------------------------------

### Configure Google Tag Manager Settings

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Defines the configuration settings for the Google Tag Manager integration in a Laravel application. This includes the Google Tag Manager container ID, a flag to enable or disable the service, the session key used for storing dataLayer information, and the domain for Google Tag Manager requests. These settings are typically stored in the `config/googletagmanager.php` file.

```php
// config/googletagmanager.php
return [
    'id' => env('GOOGLE_TAG_MANAGER_ID', 'GTM-XXXXXX'),
    'enabled' => env('GOOGLE_TAG_MANAGER_ENABLED', true),
    'sessionKey' => '_googleTagManager',
    'domain' => 'www.googletagmanager.com', // or 'gtm.yourdomain.com' for server-side GTM
];
```

--------------------------------

### Track Purchases Using Custom Macros (PHP)

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This snippet illustrates how to use a custom 'trackPurchase' macro defined in AppServiceProvider to send purchase data to Google Tag Manager. It shows a controller method that calls the macro with an order object and sets a general 'purchase_complete' event. This simplifies the process of tracking e-commerce purchases.

```php
<?php
// app/Http/Controllers/CheckoutController.php
use App\Models\Order;
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class CheckoutController extends Controller
{
    public function success(Order $order)
    {
        // Use the macro
        GoogleTagManager::trackPurchase($order);

        GoogleTagManager::set('event', 'purchase_complete');

        return view('checkout.success', compact('order'));
    }
}

```

--------------------------------

### Set and Merge DataLayer Variables in Laravel

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Demonstrates using the `set` method to add and merge data into the DataLayer. It supports simple key-value pairs and nested structures using dot notation.

```php
// Add data to the data layer (automatically renders right before the tag manager script). Setting new values merges them with the previous ones. Set also supports dot notation.
GoogleTagManager::set(['foo' => 'bar']);
GoogleTagManager::set('baz', ['ho' => 'dor']);
GoogleTagManager::set('baz.ho', 'doorrrrr');

// [
//   'foo' => 'bar',
//   'baz' => ['ho' => 'doorrrrr']
// ]
```

--------------------------------

### Flash DataLayer Variable for Next Request in Laravel

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Shows how to set a DataLayer variable ('formResponse') that will be available on the next request after a redirect. This is useful for passing temporary state, like form submission results.

```php
// ContactController.php

public function getContact()
{
    GoogleTagManager::set('pageType', 'contact');

    return view('contact');
}

public function postContact()
{
    // Do contact form stuff...

    GoogleTagManager::flash('formResponse', 'success');

    return redirect()->action('ContactController@getContact');
}
```

--------------------------------

### Handle GTM Product Click Event with JavaScript

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Provides a JavaScript snippet to handle click events on elements with the `data-gtm-click` attribute. It pushes product data to the dataLayer and handles redirection upon event completion.

```javascript
$('[data-gtm-click]').on('click', function(event) {
    event.preventDefault();
    var self = this;
    dataLayer.push({
        'event': 'productClick',
        'ecommerce': {
            'click': {
                'products': $(self).data('gtm-product')
            }
        },
        'eventCallback': function() {
            document.location = $(self).attr('href');
        }
    });
});
```

--------------------------------

### Registering Macros in Service Provider (PHP)

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/UPGRADING.md

This code snippet demonstrates how to register custom macros for Google Tag Manager in a Laravel service provider. It replaces the functionality previously handled by the `macroPath` configuration option. Ensure you have the `SpatieGoogleTagManagerGoogleTagManager` class imported.

```php
use Spatie\GoogleTagManager\GoogleTagManager;

public function boot(): void
{
    GoogleTagManager::macro('impression', function ($product) {
        GoogleTagManager::set('ecommerce', ['product' => $product->id]);
    });
}
```

--------------------------------

### Flash Push Event Data in Laravel

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Illustrates how to use `flashPush` to add event data to the DataLayer on the next request. This method is suitable for events that might otherwise overwrite existing data.

```php
// OAuthController.php

public function callback()
{
    // Authenticate user
    if ($user->wasRecentlyCreated) {
        GoogleTagManager::flashPush(['event' => 'sign_up', 'method' => 'OAuth');
    }
    GoogleTagManager::flashPush(['event' => 'login', 'method' => 'OAuth');

    return redirect()->intended();
}
```

--------------------------------

### Set DataLayer Values with Laravel Google Tag Manager

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Demonstrates how to add various types of data to the Google Tag Manager dataLayer using the `GoogleTagManagerFacade`. This includes simple key-value pairs, nested array structures, and values set using dot notation for hierarchical data. This data is then rendered as a JSON script in the page's head section.

```php
// app/Http/Controllers/ProductController.php
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class ProductController extends Controller
{
    public function show($id)
    {
        $product = Product::findOrFail($id);

        // Simple key-value pairs
        GoogleTagManager::set('pageType', 'productDetail');
        GoogleTagManager::set('productId', $product->id);

        // Array data
        GoogleTagManager::set([
            'ecommerce' => [
                'detail' => [
                    'products' => [[
                        'name' => $product->name,
                        'id' => $product->id,
                        'price' => $product->price,
                        'brand' => $product->brand,
                        'category' => $product->category,
                    ]]
                ]
            ]
        ]);

        // Dot notation for nested values
        GoogleTagManager::set('user.id', auth()->id());
        GoogleTagManager::set('user.tier', auth()->user()->membership_tier);

        return view('products.show', compact('product'));
    }
}
```

--------------------------------

### Control GTM Script Rendering Dynamically in PHP

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Control the rendering of Google Tag Manager scripts at runtime in PHP. This includes checking the current status, disabling or enabling GTM, retrieving the container ID, and changing the GTM ID dynamically. Useful for scenarios like disabling GTM for specific users or during testing.

```php
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

// Check current status
if (GoogleTagManager::isEnabled()) {
    // GTM is active
}

// Disable GTM (useful for admin users, testing, etc.)
GoogleTagManager::disable();

// Re-enable GTM
GoogleTagManager::enable();

// Get GTM container ID
$containerId = GoogleTagManager::id(); // Returns: GTM-XXXXXX

// Change GTM ID at runtime (advanced use case)
GoogleTagManager::setId('GTM-DIFFERENT');
```

--------------------------------

### Include Google Tag Manager Scripts in Blade Layout

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Includes the necessary Google Tag Manager scripts into the main Blade layout file of a Laravel application. `@include('googletagmanager::head')` renders the script tags in the `<head>` section, and `@include('googletagmanager::body')` can be used for scripts that need to be placed in the `<body>` tag. This ensures the dataLayer is initialized and ready for tracking.

```blade
{{-- resources/views/layouts/app.blade.php --}}
<html>
<head>
    @include('googletagmanager::head')
</head>
<body>
    @include('googletagmanager::body')
    {{-- Your content --}}
</body>
</html>
```

--------------------------------

### Define and Use Custom Macro in Laravel GoogleTagManager

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

This snippet demonstrates how to define a custom macro named 'impression' for the GoogleTagManager class and then use it to set e-commerce impression data. It requires the GoogleTagManager facade to be available.

```php
GoogleTagManager::macro('impression', function ($product) {
    GoogleTagManager::set('ecommerce', [
        'currencyCode' => 'EUR',
        'detail' => [
            'products' => [ $product->getGoogleTagManagerData() ]
        ]
    ]);
});

GoogleTagManager::impression($product);
```

--------------------------------

### Register Service Provider and Facade in Laravel 4

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Manually registers the GoogleTagManagerServiceProvider and GoogleTagManagerFacade in the config/app.php file for Laravel versions prior to 5.5. This ensures the package's core functionalities are available.

```php
// config/app.php

'providers' => [
    ...
    Spatie\GoogleTagManager\GoogleTagManagerServiceProvider::class,
],

'aliases' => [
    ...
    'GoogleTagManager' => Spatie\GoogleTagManager\GoogleTagManagerFacade::class,
]
```

--------------------------------

### Add Google Tag Manager Middleware for Flash Data

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Integrates the GoogleTagManagerMiddleware into the application's HTTP kernel for Laravel 5.5+. This middleware must be placed after the StartSession middleware to enable flash functionality for data passed between requests.

```php
// app/Http/Kernel.php

protected $middleware = [
    ...
    \Illuminate\Session\Middleware\StartSession::class,
    \Spatie\GoogleTagManager\GoogleTagManagerMiddleware::class,
    ...
];
```

--------------------------------

### Include Google Tag Manager Scripts in Blade

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Includes the necessary Google Tag Manager scripts for both the head and body sections of a Blade layout. This is essential for the package to function correctly.

```blade
<html>
  <head>
    @include('googletagmanager::head')
    {{-- ... --}}
  </head>
  <body>
    @include('googletagmanager::body')
    {{-- ... --}}
  </body>
</html>
```

--------------------------------

### Embed Product Data in HTML for Client-Side Tracking (PHP, Blade)

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This snippet demonstrates how to embed product data into HTML attributes using GoogleTagManager::dump() for client-side JavaScript tracking. It involves a Laravel controller to fetch category and product data and a Blade view to render product cards with data attributes. The embedded JSON data is then parsed by JavaScript to push events to the dataLayer.

```php
<?php
// app/Http/Controllers/CategoryController.php
use App\Models\Category;
use Illuminate\Support\Facades\View;
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class CategoryController extends Controller
{
    public function show($slug)
    {
        $category = Category::where('slug', $slug)->firstOrFail();
        $products = $category->products()->paginate(20);

        GoogleTagManager::set('pageType', 'category');
        GoogleTagManager::set('categoryName', $category->name);

        return view('category.show', compact('category', 'products'));
    }
}

```

```blade
{{-- resources/views/category/show.blade.php --}}
<div class="products-grid">
    @foreach($products as $product)
        <a href="{{ route('products.show', $product->id) }}"
           class="product-card"
           data-gtm-product='{!! GoogleTagManager::dump([
               "id" => $product->id,
               "name" => $product->name,
               "price" => $product->price,
               "category" => $product->category,
               "position" => $loop->iteration
           ]) !!}'
           data-gtm-click>
            <img src="{{ $product->image }}" alt="{{ $product->name }}">
            <h3>{{ $product->name }}</h3>
            <p>${{ $product->price }}</p>
        </a>
    @endforeach
</div>

<script>
document.querySelectorAll('[data-gtm-click]').forEach(function(element) {
    element.addEventListener('click', function(event) {
        event.preventDefault();
        var productData = JSON.parse(this.getAttribute('data-gtm-product'));

        window.dataLayer.push({
            'event': 'productClick',
            'ecommerce': {
                'click': {
                    'actionField': {'list': '{{ $category->name }}'},
                    'products': [productData]
                }
            },
            'eventCallback': function() {
                document.location = element.href;
            }
        });
    });
});
</script>

```

--------------------------------

### Register Google Tag Manager Middleware

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

Registers the `GoogleTagManagerMiddleware` within the application's HTTP kernel. This middleware is responsible for handling session-based flash data related to Google Tag Manager, ensuring that tracking information is correctly passed across redirects. It should be placed after the session middleware.

```php
// app/Http/Kernel.php - Register middleware for flash functionality
protected $middleware = [
    \Illuminate\Session\Middleware\StartSession::class,
    \Spatie\GoogleTagManager\GoogleTagManagerMiddleware::class,
];
```

--------------------------------

### Flash Data for Next Request in Laravel

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

This snippet demonstrates how to use GoogleTagManager::flash() in Laravel to store dataLayer values that persist through redirects. This is useful for sending data like form submission events or user actions that occur before a redirect.

```php
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class ContactController extends Controller
{
    public function show()
    {
        // This data renders on current page
        GoogleTagManager::set('pageType', 'contact');

        return view('contact.form');
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required',
            'email' => 'required|email',
            'message' => 'required',
        ]);

        // Send email, store in database, etc.

        // Flash data for the NEXT request (after redirect)
        GoogleTagManager::flash('event', 'form_submission');
        GoogleTagManager::flash('formType', 'contact');
        GoogleTagManager::flash('conversionValue', 100);

        // Flash also supports arrays and dot notation
        GoogleTagManager::flash([
            'user' => [
                'action' => 'contacted',
                'timestamp' => now()->toIso8601String(),
            ]
        ]);

        return redirect()->route('contact.show')
            ->with('success', 'Thank you for contacting us!');
    }
}
```

--------------------------------

### Set DataLayer Variable in Laravel Controller

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Demonstrates how to set a DataLayer variable ('pageType') within a Laravel controller using the GoogleTagManager facade. This data will be available in the rendered view.

```php
// HomeController.php

public function index()
{
    GoogleTagManager::set('pageType', 'productDetail');

    return view('home');
}
```

--------------------------------

### Dump Array to JSON for HTML Attribute in Blade

Source: https://github.com/spatie/laravel-googletagmanager/blob/main/README.md

Shows how to use `GoogleTagManager::dump()` to convert a PHP array (e.g., a product's data) into a JSON string suitable for use within an HTML data attribute.

```blade
<a data-gtm-product='{!! GoogleTagManager::dump($product->toArray()) !!}' data-gtm-click>Product</a>
```

--------------------------------

### Disable GTM for Admin Users Middleware in PHP

Source: https://context7.com/spatie/laravel-googletagmanager/llms.txt

A middleware to disable Google Tag Manager for authenticated administrators. This ensures that tracking scripts are not loaded for users with administrative privileges, which can be useful for internal testing or avoiding self-tracking.

```php
// app/Http/Middleware/DisableGtmForAdmin.php
use Illuminate\Http\Request;
use Closure;
use Spatie\GoogleTagManager\GoogleTagManagerFacade as GoogleTagManager;

class DisableGtmForAdmin
{
    public function handle($request, Closure $next)
    {
        if (auth()->check() && auth()->user()->is_admin) {
            GoogleTagManager::disable();
        }

        return $next($request);
    }
}
```
Tokens:
Raw