# Contribution guide

Contributions are
welcome
and will be fully
credited
.

We accept contributions through Pull Requests on
[all projects](https://github.com/TheDragonCode)
of our organization.

## Code Style

Laravel Feeds
follows the
[PER-3](https://www.php-fig.org/per/coding-style/) coding standard and the
[PSR-4](https://www.php-fig.org/psr/psr-4/) autoloading standard.

To apply code style formatting, run the following console command:

```BASH
composer style
```

## Code of Conduct

The Laravel code of conduct is derived from the
[Contributor Covenant](https://www.contributor-covenant.org/version/2/1/code_of_conduct/)
code of conduct.
Any violations of the code of conduct may be reported to
[Andrey Helldar](mailto:helldar@dragon-code.pro):

* Participants should be tolerant of opposing views.

* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.

* When interpreting the words and actions of others, participants should always assume good intentions.

* Behavior that can be reasonably considered harassment will not be tolerated.



# Machine Learning

You can help your LLM understand the structure and conventions of this project much better.

To do that, import the guidance from the following file:
[llms.txt](https://feeds.dragon-code.pro/llms.txt).

This file is a single, consolidated Markdown document containing the compiled documentation for this project. It is designed to be used as a knowledge base for LLMs (for example, as a system prompt attachment, a retrieval corpus, or a custom knowledge file).

Note:

Save the URL and re-import it periodically to pick up updates as the project evolves.



# MIT License

Copyright (c) 2025 Andrey Helldar

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the “Software”), to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions
of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.



# Getting started

📃 Laravel Feeds

An easy and fast way to export large amounts of data to feeds for marketplaces and other consumers.



# Installation & setup

You can install the package via [Composer](https://getcomposer.org):

```BASH
composer require dragon-code/laravel-feeds
```

You should publish the
[migration](https://github.com/TheDragonCode/laravel-feeds/blob/main/database/migrations/2025_09_01_231655_create_feeds_table.php)
and the
[config/feeds.php](https://github.com/TheDragonCode/laravel-feeds/blob/main/config/feeds.php)
config file with:

```BASH
php artisan vendor:publish --tag="feeds"
```

Warning:

Before running migrations, check the database connection settings in the
`config/feeds.php` file.

Now you can run migrations and proceed to [create feeds](create-feeds.html).

```BASH
php artisan migrate
```



# Create feeds

Note:

The most convenient way to create the necessary classes is to use the
[Laravel Idea](http://laravel-idea.com) plugin for
[PhpStorm](https://www.jetbrains.com/phpstorm/).

![Laravel Idea](images/laravel-idea.png)

To create a feed class, use the `make:feed` console command:

```BASH
php artisan make:feed <name>
```

This will create a feed file. For example, `app/Feeds/UserFeed.php`.

This console command can also create the item and info classes along with the feed class.
To do this, use the `--item` and `--info` options.

```BASH
# Create a feed class and info class
php artisan make:feed <name> --info

# Create a feed class and item class
php artisan make:feed <name> --item

# Create a feed class, item class, and info class
php artisan make:feed <name> --item --info
```

Shortcuts are also available:

```BASH
# Create a feed class and item class
php artisan make:feed <name> -t

# Create a feed class and info class
php artisan make:feed <name> -i

# Create a feed class, item class, and info class
php artisan make:feed <name> -it
```

Note:

When creating a feed, an operation or a migration will also be created to add it to the database.

If the project uses
[Laravel Deploy Operations](https://deploy-operations.dragon-code.pro), then an operation class will be created; otherwise, a migration class will be created.

This is required to add and manage feed information in the database.

## Populating feeds

### Feed

Populate the main feed class. For example:

```PHP
namespace App\Feeds;

use App\Feeds\Items\UserFeedItem;
use App\Models\User;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class UserFeed extends Feed
{
    public function builder(): Builder
    {
        return User::query()
            ->whereNotNull('email_verified_at')
            ->where('created_at', '>', now()->subYear());
    }

    public function item(Model $model): FeedItem
    {
        return new UserFeedItem($model);
    }
}
```

#### Feed item

Populate the feed item class. For example:

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

/** @property-read \App\Models\User $model */
class UserFeedItem extends FeedItem
{
    public function toArray(): array
    {
        return [
            'name'  => $this->model->class,
            'email' => $this->model->email,
        ];
    }
}
```

## File format

Tip:

You can find the list of available formats on the
[supported formats](supported-formats.html) page.

You can generate feeds in different formats.
A feed class can be correctly exported only to the format for which it is intended.
This is due to the use of
[directives](directives.html) and other format specifics.

To apply the required format, simply override the `$format` property in the feed class:

```PHP
namespace App\Feeds;

use DragonCode\LaravelFeed\Enums\FeedFormatEnum;
use DragonCode\LaravelFeed\Feeds\Feed;
use Illuminate\Database\Eloquent\Builder;

class UserFeed extends Feed
{
    protected FeedFormatEnum $format = FeedFormatEnum::Json;

    public function builder(): Builder
    {
        //
    }
}
```



# Generation & schedule

To generate all active feeds, use the console command:

```BASH
php artisan feed:generate
```

As a result, all active feeds (`is_active = true`) will be executed from the
`feeds` table (or the one you specified in the `config/feeds.php` file).

Tip:

Please note that when you call the command without a parameter,
the console will display links to all feeds,
even those with the `is_active` property set to `false`.

However, instead of being executed, such feeds will be marked with the
`SKIP` status.

## Single feed

Warning:

Please note that the specified feed
will be executed
even if it is disabled in the
`feeds` table in the database.

To generate a specific feed, call the `feed:generate` console command,
passing the feed ID from the `feeds` table as its parameter:

```BASH
php artisan feed:generate 123
```

## Schedule

### Automatic

To automate feed generation, use a
[schedule](https://laravel.com/docs/scheduling#running-the-scheduler).
To do this, specify the helper call in the
`routes/console.php` file (the default path, unless you have changed it):

```PHP
use DragonCode\LaravelFeed\Helpers\ScheduleFeedHelper;
use Illuminate\Support\Facades\Schedule;

ScheduleFeedHelper::register();

Schedule::call(function () {
    // ... other action
})->everySecond();
```

This will enable you to register calls to all active feeds according to the schedule you specified in the
`expression` column of the database.

### Manual

You can also specify the schedule directly according to your own rules.
In this case, only the feeds you specify will be executed.

```PHP
use DragonCode\LaravelFeed\Commands\FeedGenerateCommand;
use Illuminate\Support\Facades\Schedule;

Schedule::command(FeedGenerateCommand::class, [111])
    ->withoutOverlapping()
    ->runInBackground()
    ->daily();

Schedule::command(FeedGenerateCommand::class, [222])
    ->withoutOverlapping()
    ->runInBackground()
    ->hourly();

Schedule::call(function () {
    // ... other action
})->everySecond();
```



# Supported formats

xml
: Generates feeds in XML format.

json
: Generates feeds in JSON format.

jsonl
: Generates feeds in JSON Lines format.

By default, the `xml` format is used.



# Elements

## Root element

Tip:

By default, the name of the root element is derived from the base name of the feed class.

For example, for the `App\Feeds\FooBarFeed` class, the name is `foo_bar`.

To add a root element and/or its attributes, override the `root` method:

```PHP
namespace App\Feeds;

use App\Models\User;
use DragonCode\LaravelFeed\Data\ElementData;
use DragonCode\LaravelFeed\Feeds\Feed;
use Illuminate\Database\Eloquent\Builder;

use function now;

class RootElementFeed extends Feed
{
    public function builder(): Builder
    {
        return User::query();
    }

    public function root(): ElementData
    {
        return new ElementData(
            name      : 'foo',
            attributes: [
                'count' => $this->builder()->count(),

                'generated_at' => now(),
            ],
        );
    }
}
```

To disable the addition of the root element, specify its name as empty — `null` or
`""`.

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<foo count="2" generated_at="2025-09-04 04:08:12">

<user>
  <id>1</id>
  <name>Mr. Jaylin Schmitt</name>
</user>
<user>
  <id>2</id>
  <name>Brenden Murazik DVM</name>
</user>

</foo>
```

## Information

To add information to the beginning of the root element (if present) or without it,
override the
`info` method in the feed class and create an object that extends the
`DragonCode\LaravelFeed\Feeds\Info\FeedInfo` class:

```PHP
namespace App\Feeds;

use App\Feeds\Info\InfoMethodFeedInfo;
use App\Models\User;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;
use Illuminate\Database\Eloquent\Builder;

class InfoMethodFeed extends Feed
{
    public function builder(): Builder
    {
        return User::query();
    }

    public function info(): FeedInfo
    {
        return new InfoMethodFeedInfo;
    }
}
```

```PHP
namespace App\Feeds\Info;

use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;

use function config;

class InfoMethodFeedInfo extends FeedInfo
{
    public function toArray(): array
    {
        return [
            'company' => config('app.name'),
            'url'     => config('app.url'),
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<info_method>

<company>Laravel</company>
<url>https://example.com</url>

<user>
  <id>1</id>
  <name>Kaelyn Robel</name>
</user>
<user>
  <id>2</id>
  <name>Kailee Gutkowski</name>
</user>

</info_method>
```

If you need to change the order in which the root element is output relative to the
information block, set the `beforeInfo` parameter in the `root` method:

```PHP
namespace App\Feeds;

use App\Feeds\Info\InfoMethodFeedInfo;
use App\Models\User;
use DragonCode\LaravelFeed\Data\ElementData;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;
use Illuminate\Database\Eloquent\Builder;

class InfoMethodBeforeFalseTest extends Feed
{
    public function builder(): Builder
    {
        return User::query();
    }

    public function root(): ElementData
    {
        return new ElementData(
            name      : 'info_method',
            beforeInfo: false
        );
    }

    public function info(): FeedInfo
    {
        return new InfoMethodFeedInfo;
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<company>Laravel</company>
<url>https://example.com</url>

<info_method>

<user>
  <id>1</id>
  <name>Dr. Marshall Jakubowski Sr.</name>
</user>
<user>
  <id>2</id>
  <name>Mafalda Trantow</name>
</user>

</info_method>
```

## Header & footer

To change the header and footer, override the `header` and `footer` methods:

```PHP
namespace App\Feeds;

use App\Models\User;
use DragonCode\LaravelFeed\Feeds\Feed;
use Illuminate\Database\Eloquent\Builder;

class HeaderFooterFeed extends Feed
{
    public function builder(): Builder
    {
        return User::query();
    }

    public function header(): string
    {
        return '<rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">';
    }

    public function footer(): string
    {
        return "\n<g:footer>This is a custom footer element</g:footer>";
    }
}
```

This code will result in:

```XML
<rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">
<header_footer>

<user>
  <id>1</id>
  <name>Carmella Prohaska IV</name>
</user>
<user>
  <id>2</id>
  <name>Emiliano Shields II</name>
</user>

</header_footer>

<g:footer>This is a custom footer element</g:footer>
```

## Attributes

```PHP
namespace App\Feeds;

use App\Feeds\Items\AttributeFeedItem;
use App\Models\User;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class AttributeFeed extends Feed
{
    public function builder(): Builder
    {
        return User::query();
    }

    public function item(Model $model): FeedItem
    {
        return new AttributeFeedItem($model);
    }
}
```

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

class AttributeFeedItem extends FeedItem
{
    public function attributes(): array
    {
        return [
            'created_at' => $this->model->created_at,
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<attribute>

<user created_at="2025-09-06T00:27:10+00:00">
  <id>1</id>
  <name>Katharina Jacobi</name>
</user>
<user created_at="2025-09-06T00:27:10+00:00">
  <id>2</id>
  <name>Kamron Lesch V</name>
</user>

</attribute>
```



# Directives

Note: Reserved directives

* [@attributes](#_attributes)

* [@value](#_value)

* [@cdata](#_cdata)

* [@mixed](#_mixed)

* [@custom](#_custom)

The use of directives is available only when generating feeds in the XML format.

## @attributes

You can use a key named `@attributes` to add attributes to a node:

```PHP
namespace App\Feeds;

use App\Feeds\Info\AttributesDirectiveFeedInfo;
use App\Feeds\Items\AttributesDirectiveFeedItem;
use App\Models\User;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;
use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class AttributesDirectiveFeed extends Feed
{
    public function builder(): Builder
    {
        return User::query();
    }

    public function info(): FeedInfo
    {
        return new AttributesDirectiveFeedInfo;
    }

    public function item(Model $model): FeedItem
    {
        return new AttributesDirectiveFeedItem($model);
    }
}
```

```PHP
namespace App\Feeds\Info;

use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;

use function fake;

class AttributesDirectiveFeedInfo extends FeedInfo
{
    public function toArray(): array
    {
        return [
            'company' => [
                '@attributes' => ['since' => fake()->year],
            ],

            'url' => config('app.url'),
        ];
    }
}
```

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

class AttributesDirectiveFeedItem extends FeedItem
{
    public function toArray(): array
    {
        return [
            'name' => $this->model->name,

            'contact' => [
                '@attributes' => [
                    'email' => $this->model->email,
                    'phone' => '555-000-' . $this->model->id,
                ],
            ],
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<attributes_directive>

<company since="2003"/>
<url>https://example.com</url>

<user>
  <name>Prof. Jaeden Hodkiewicz</name>
  <contact email="kutch.santos@example.com" phone="555-000-1"/>
</user>
<user>
  <name>Miss Annetta Frami MD</name>
  <contact email="okeefe.kristian@example.org" phone="555-000-2"/>
</user>

</attributes_directive>
```

## @value

Tip:

Note that the value of the `@value` field must be a string.

You can use a key named `@value` to add value to a node:

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

class ValueDirectiveFeedItem extends FeedItem
{
    public function toArray(): array
    {
        return [
            'name' => [
                '@value' => $this->model->name,
            ],

            'contact' => [
                '@attributes' => ['type' => 'email'],
                '@value'      => $this->model->email,
            ],
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<value_directive>

<user>
  <name>Arely Weber</name>
  <contact type="email">chermann@example.net</contact>
</user>
<user>
  <name>Cali Corkery PhD</name>
  <contact type="email">swalter@example.org</contact>
</user>

</value_directive>
```

## @cdata

Tip:

It is also possible to wrap the value of a node into a CDATA section.
This allows you to use reserved characters.

You can use a key named `@cdata` to add CDATA to a node:

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

use function sprintf;

class CdataDirectiveFeedItem extends FeedItem
{
    public function toArray(): array
    {
        return [
            'name' => [
                '@cdata' => sprintf('<h1>%s</h1>', $this->model->name),
            ],

            'email' => $this->model->email,
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<cdata_directive>

<user>
  <name><![CDATA[<h1>Mrs. Elsie Heathcote DVM</h1>]]></name>
  <email>arielle43@example.net</email>
</user>
<user>
  <name><![CDATA[<h1>Davin Raynor MD</h1>]]></name>
  <email>andreanne.jaskolski@example.com</email>
</user>

</cdata_directive>
```

## @mixed

To insert XML fragments “as is”, use the `@mixed` directive:

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

class MixedDirectiveFeedItem extends FeedItem
{
    public function toArray(): array
    {
        return [
            'name' => $this->model->name,

            '@mixed' => <<<XML
                <some>
                    <first>Foo</first>
                    <second>{$this->model->email}</second>
                </some>
                XML,
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<mixed_directive>

<user>
  <name>Veronica Hahn</name>
  <some>
    <first>Foo</first>
    <second>xauer@example.net</second>
</some>
</user>
<user>
  <name>Brett Weber</name>
  <some>
    <first>Foo</first>
    <second>rrolfson@example.com</second>
</some>
</user>

</mixed_directive>
```

## @custom

In some cases, you need to place an array of elements with the same names.

To do this, add a `@` symbol to the start of the key name:

```PHP
namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

use function fake;

class ArrayDirectiveFeedItem extends FeedItem
{
    public function toArray(): array
    {
        return [
            'name' => $this->model->name,

            '@avatar' => [
                fake()->imageUrl(),
                fake()->imageUrl(),
            ],

            '@images' => [
                [
                    '@attributes' => ['name' => fake()->words(asText: true)],
                    '@value'      => fake()->imageUrl(),
                ],
                [
                    '@attributes' => ['name' => fake()->words(asText: true)],
                    '@value'      => fake()->imageUrl(),
                ],
            ],
        ];
    }
}
```

This code will result in:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<array_directive>

<user>
  <name>Brandi Shields</name>
  <avatar>https://via.placeholder.com/640x480.png/00ddaa?text=aut</avatar>
  <avatar>https://via.placeholder.com/640x480.png/005566?text=error</avatar>
  <images name="nemo cumque consequatur">https://via.placeholder.com/640x480.png/0066dd?text=eveniet</images>
  <images name="atque quaerat officiis">https://via.placeholder.com/640x480.png/0000aa?text=repudiandae</images>
</user>
<user>
  <name>Taya Vandervort</name>
  <avatar>https://via.placeholder.com/640x480.png/000011?text=deserunt</avatar>
  <avatar>https://via.placeholder.com/640x480.png/000088?text=iusto</avatar>
  <images name="dolor cum perferendis">https://via.placeholder.com/640x480.png/00eecc?text=vero</images>
  <images name="est vitae excepturi">https://via.placeholder.com/640x480.png/009955?text=ratione</images>
</user>

</array_directive>
```



# Eloquent

## Chunk size

Database queries use chunks, which are `1000` items by default.
You can change this by overriding the `chunkSize` method:

```PHP
use DragonCode\LaravelFeed\Feeds\Feed;

class UserFeed extends Feed
{
    public function chunkSize(): int
    {
        return 500;
    }
}
```



# Location

By default, feeds are stored in `public` storage,
and the file name will be automatically generated from the feed class name after
`App\Feeds\` in `kebab-case` format.
For example:

```TEXT
# App\Feeds\UserFeed
user-feed.xml

# App\Feeds\Sitemaps\ProductFeed
sitemaps-product-feed.xml
```

You can change these values by overriding the `$storage` property and the
`filename` method:

```PHP
use DragonCode\LaravelFeed\Feeds\Feed;

class UserFeed extends Feed
{
    protected string $storage = 'public';

    public function filename(): string
    {
        return 'some/path/will/be/here.xml';
    }
}
```



# Events

Feeds dispatch two events when running the command:

DragonCode\LaravelFeed\Events\FeedStartingEvent
: The
: `FeedStartingEvent`
: is dispatched immediately before the draft file is created.

DragonCode\LaravelFeed\Events\FeedFinishedEvent
: The
: `FeedFinishedEvent`
: is dispatched right after the feed file generation has completed.



# Sitemap

This recipe walks you through creating a product sitemap feed using Laravel Feeds. You will:
- Generate the necessary classes
- Implement the feed logic
- Expose the files via the file system
- Optionally reference the generated sitemap from a root sitemap.xml file

## Create the files

Generate the feed and its item class using the following console command:

```BASH
php artisan make:feed Sitemaps/Product -t
```

## Populate the feed

Implement the feed root element, attributes, query builder, output filename, and item mapping as shown below:

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds\Sitemaps;

use App\Feeds\Sitemaps\Items\ProductFeedItem;
use App\Models\Product;
use DragonCode\LaravelFeed\Data\ElementData;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class ProductFeed extends Feed
{
    protected string $name = 'urlset';

    protected array $attributes = [
        'xmlns'       => 'http://www.sitemaps.org/schemas/sitemap/0.9',
        'xmlns:xhtml' => 'http://www.w3.org/1999/xhtml',
        'xmlns:image' => 'http://www.google.com/schemas/sitemap-image/1.1',
        'xmlns:video' => 'http://www.google.com/schemas/sitemap-video/1.1',
        'xmlns:news'  => 'http://www.google.com/schemas/sitemap-news/0.9',
    ];

    public function builder(): Builder
    {
        return Product::query();
    }

    public function root(): ElementData
    {
        return new ElementData(
            name      : $this->name,
            attributes: $this->attributes,
        );
    }

    public function item(Model $model): FeedItem
    {
        return new ProductFeedItem($model);
    }

    public function filename(): string
    {
        return 'sitemaps/products.xml';
    }
}
```

## Populate the feed item

Define the XML element name and map your model’s properties to the corresponding sitemap tags:

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds\Sitemaps\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

use function route;

/** @property-read \App\Models\Product $model */
class ProductFeedItem extends FeedItem
{
    public function name(): string
    {
        return 'url';
    }

    public function toArray(): array
    {
        return [
            'loc' => route('products.show', $this->model->slug),

            'lastmod' => $this->model->updated_at,

            'priority' => 0.9,
        ];
    }
}
```

## Activate

Review the generated [operation or migration](create-feeds.html) file, then run the appropriate console command:

```BASH
# For Laravel Deploy Operations
php artisan operations

# For Laravel Migrations
php artisan migrate
```

## Links

Add a file system disk that points to the directory containing your sitemaps in
the [config/filesystems.php](https://github.com/laravel/laravel/blob/12.x/config/filesystems.php#L76-L78) configuration file:

```PHP
return [
    'links' => [
        public_path('storage')  => storage_path('app/public'),
        public_path('sitemaps') => storage_path('app/public/sitemaps'),
    ],
];
```

Then create the public symlink so the files are accessible in a browser:

```BASH
php artisan storage:link
```

## Generate feed

Generate the feed by running the following console command:

```BASH
php artisan feed:generate
```

## Add a link to the root sitemap.xml

If you maintain a root sitemap.xml file that references other sitemaps, add an entry like this:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
    <sitemap>
        <loc>https://example.com/sitemaps/products.xml</loc>
    </sitemap>
    <sitemap>
        <loc>https://example.com/sitemaps/other-sitemaps.xml</loc>
    </sitemap>
</sitemapindex>
```

## Result

The generated sitemap.xml for your products will look like this:

```XML
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">

<url>
  <loc>https://example.com/products/quidem-tempore-nulla-repudiandae-vero</loc>
  <lastmod>2025-09-04T04:08:12+00:00</lastmod>
  <priority>0.9</priority>
</url>
<url>
  <loc>https://example.com/products/laudantium-porro-qui-rerum-incidunt-expedita</loc>
  <lastmod>2025-09-04T04:08:12+00:00</lastmod>
  <priority>0.9</priority>
</url>

</urlset>
```



# Instagram

## Create the files

```BASH
php artisan make:feed Instagram -t
```

## Populate the feed

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds;

use App\Feeds\Items\InstagramFeedItem;
use App\Models\Product;
use DragonCode\LaravelFeed\Data\ElementData;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class InstagramFeed extends Feed
{
    public function builder(): Builder
    {
        return Product::query();
    }

    public function root(): ElementData
    {
        return new ElementData('offers');
    }

    public function header(): string
    {
        $name = config('app.name');
        $url  = config('app.url');

        return <<<XML
            <rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">
            <channel>
                <title>$name</title>
                <link>$url</link>

            XML;
    }

    public function footer(): string
    {
        return "\n</channel>\n</rss>";
    }

    public function item(Model $model): FeedItem
    {
        return new InstagramFeedItem($model);
    }

    public function filename(): string
    {
        return 'instagram.xml';
    }
}
```

## Populate the feed item

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Support\Arr;

use function collect;
use function fake;

/** @property-read \App\Models\Product $model */
class InstagramFeedItem extends FeedItem
{
    public function name(): string
    {
        return 'item';
    }

    public function toArray(): array
    {
        return [
            'g:id' => $this->model->id,

            'g:title'       => ['@cdata' => $this->model->title],
            'g:description' => ['@cdata' => $this->model->description],

            'g:link'       => route('products.show', $this->model->slug),
            'g:image_link' => $this->firstImage(),

            '@g:additional_image_link' => $this->images(),

            'g:brand'        => $this->model->brand,
            'g:condition'    => 'new',
            'g:availability' => 'in stock',

            'g:price'      => $this->model->price,
            'g:sale_price' => $this->model->price,

            'g:item_group_id' => 12345,

            'g:status' => 'active',

            'g:color' => ['@cdata' => fake()->colorName()],

            'g:size' => fake()->numberBetween(10, 50),

            'g:age_group' => 'adult',

            'g:material' => ['@cdata' => fake()->word()],
            'g:pattern'  => ['@cdata' => 'regular'],

            'g:google_product_category' => 1000,
            'g:fb_product_category'     => 2000,
        ];
    }

    protected function firstImage(): string
    {
        return Arr::first($this->model->images);
    }

    protected function images(): array
    {
        return collect($this->model->images)->skip(1)->all();
    }
}
```

## Activate

Review the generated [operation or migration](create-feeds.html) file, then run the appropriate console command:

```BASH
# For Laravel Deploy Operations
php artisan operations

# For Laravel Migrations
php artisan migrate
```

## Generate feed

Generate the feed by running the following console command:

```BASH
php artisan feed:generate
```

## Result

```XML
<rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">
<channel>
    <title>Laravel</title>
    <link>https://example.com</link>
<offers>

<item>
  <g:id>1</g:id>
  <g:title><![CDATA[amet suscipit aut corrupti]]></g:title>
  <g:description><![CDATA[Eveniet odit ut est beatae quis. Qui autem voluptatem voluptate qui quam maiores. Est repellendus similique aliquid repudiandae alias. Hic ea et omnis ut.]]></g:description>
  <g:link>https://example.com/products/inventore-velit-quasi-sed-enim-cupiditate</g:link>
  <g:image_link>https://via.placeholder.com/640x480.png/0000aa?text=quis</g:image_link>
  <g:additional_image_link>https://via.placeholder.com/640x480.png/0022ff?text=neque</g:additional_image_link>
  <g:additional_image_link>https://via.placeholder.com/640x480.png/00eeee?text=est</g:additional_image_link>
  <g:brand>quia</g:brand>
  <g:condition>new</g:condition>
  <g:availability>in stock</g:availability>
  <g:price>953</g:price>
  <g:sale_price>953</g:sale_price>
  <g:item_group_id>12345</g:item_group_id>
  <g:status>active</g:status>
  <g:color><![CDATA[OrangeRed]]></g:color>
  <g:size>12</g:size>
  <g:age_group>adult</g:age_group>
  <g:material><![CDATA[eum]]></g:material>
  <g:pattern><![CDATA[regular]]></g:pattern>
  <g:google_product_category>1000</g:google_product_category>
  <g:fb_product_category>2000</g:fb_product_category>
</item>
<item>
  <g:id>2</g:id>
  <g:title><![CDATA[rem sunt exercitationem nulla]]></g:title>
  <g:description><![CDATA[Et perferendis consequuntur voluptatem voluptatem nemo omnis quod. Qui est tempore numquam molestias consequatur nam. Quis quia dicta a. Quo incidunt facilis cum voluptatum quasi ut.]]></g:description>
  <g:link>https://example.com/products/et-sunt-eligendi-quos-explicabo-et-qui</g:link>
  <g:image_link>https://via.placeholder.com/640x480.png/002277?text=nesciunt</g:image_link>
  <g:additional_image_link>https://via.placeholder.com/640x480.png/0022aa?text=natus</g:additional_image_link>
  <g:additional_image_link>https://via.placeholder.com/640x480.png/0033dd?text=impedit</g:additional_image_link>
  <g:brand>possimus</g:brand>
  <g:condition>new</g:condition>
  <g:availability>in stock</g:availability>
  <g:price>292</g:price>
  <g:sale_price>292</g:sale_price>
  <g:item_group_id>12345</g:item_group_id>
  <g:status>active</g:status>
  <g:color><![CDATA[DarkGreen]]></g:color>
  <g:size>49</g:size>
  <g:age_group>adult</g:age_group>
  <g:material><![CDATA[molestias]]></g:material>
  <g:pattern><![CDATA[regular]]></g:pattern>
  <g:google_product_category>1000</g:google_product_category>
  <g:fb_product_category>2000</g:fb_product_category>
</item>

</offers>

</channel>
</rss>
```



# Yandex

## Create the files

```BASH
php artisan make:feed Yandex -it
```

## Populate the feed

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds;

use App\Feeds\Info\YandexFeedInfo;
use App\Feeds\Items\YandexFeedItem;
use App\Models\Product;
use DragonCode\LaravelFeed\Data\ElementData;
use DragonCode\LaravelFeed\Feeds\Feed;
use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;
use DragonCode\LaravelFeed\Feeds\Items\FeedItem;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class YandexFeed extends Feed
{
    public function builder(): Builder
    {
        return Product::query();
    }

    public function root(): ElementData
    {
        return new ElementData('offers', beforeInfo: false);
    }

    public function header(): string
    {
        $date = now()->toIso8601String();

        return <<<XML
            <!DOCTYPE yml_catalog SYSTEM "shops.dtd">
            <yml_catalog date="$date">
                <shop>
            XML;
    }

    public function footer(): string
    {
        return "</shop>\n</yml_catalog>";
    }

    public function info(): FeedInfo
    {
        return new YandexFeedInfo;
    }

    public function item(Model $model): FeedItem
    {
        return new YandexFeedItem($model);
    }

    public function filename(): string
    {
        return 'yandex.xml';
    }
}
```

## Populate the feed info

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds\Info;

use DragonCode\LaravelFeed\Feeds\Info\FeedInfo;

class YandexFeedInfo extends FeedInfo
{
    public function toArray(): array
    {
        return [
            'name'     => config('app.name'),
            'company'  => config('app.name'),
            'platform' => config('app.name'),

            'url'   => config('app.url'),
            'email' => config('emails.manager'),

            'currencies' => [
                '@currency' => [
                    [
                        '@attributes' => [
                            'id'   => 'RUR',
                            'rate' => '1',
                        ],
                    ],
                ],
            ],

            'categories' => [
                '@category' => [
                    [
                        '@attributes' => ['id' => 41],
                        '@value'      => 'Домашние майки',
                    ],
                    [
                        '@attributes' => ['id' => 539],
                        '@value'      => 'Велосипедки',
                    ],
                ],
            ],
        ];
    }
}
```

## Populate the feed item

```PHP
<?php

declare(strict_types=1);

namespace App\Feeds\Items;

use DragonCode\LaravelFeed\Feeds\Items\FeedItem;

/** @property-read \App\Models\Product $model */
class YandexFeedItem extends FeedItem
{
    public function name(): string
    {
        return 'offer';
    }

    public function attributes(): array
    {
        return [
            'id' => $this->model->id,

            'available' => ! empty($this->model->quantity) ? 'true' : 'false',

            'type' => 'vendor.model',
        ];
    }

    public function toArray(): array
    {
        return [
            'url' => route('products.show', $this->model->slug),

            'barcode'     => $this->model->article,
            'name'        => $this->model->title,
            'description' => $this->model->description,

            'delivery' => 'true',
            'price'    => $this->model->price,

            'currencyId' => 'RUR',
            'vendor'     => $this->model->brand,

            '@picture' => $this->model->images,

            '@param' => [
                [
                    '@attributes' => ['name' => 'Артикул'],
                    '@value'      => $this->model->article,
                ],
                [
                    '@attributes' => ['name' => 'Код цвета'],
                    '@value'      => fake()->randomDigit(),
                ],
                [
                    '@attributes' => ['name' => 'Пол'],
                    '@value'      => fake()->boolean() ? 'male' : 'female',
                ],
            ],
        ];
    }
}
```

## Activate

Review the generated [operation or migration](create-feeds.html) file, then run the appropriate console command:

```BASH
# For Laravel Deploy Operations
php artisan operations

# For Laravel Migrations
php artisan migrate
```

## Generate feed

Generate the feed by running the following console command:

```BASH
php artisan feed:generate
```

## Result

```XML
<!DOCTYPE yml_catalog SYSTEM "shops.dtd">
<yml_catalog date="2025-09-04T04:08:12+00:00">
    <shop>
<name>Laravel</name>
<company>Laravel</company>
<platform>Laravel</platform>
<url>https://example.com</url>
<email>test@example.com</email>
<currencies>
  <currency id="RUR" rate="1"/>
</currencies>
<categories>
  <category id="41">Домашние майки</category>
  <category id="539">Велосипедки</category>
</categories>

<offers>

<offer id="1" available="true" type="vendor.model">
  <url>https://example.com/products/quas-aut-omnis-dolorum-nulla-quo-nisi</url>
  <barcode>GD-WG&amp;$VS</barcode>
  <name>dolorum architecto doloremque voluptatem</name>
  <description>Asperiores eum ab deleniti ipsum consequatur consequatur totam dolorum. Velit amet in ducimus quis non unde. Delectus magnam et rerum aut quibusdam enim natus.</description>
  <delivery>true</delivery>
  <price>145</price>
  <currencyId>RUR</currencyId>
  <vendor>ea</vendor>
  <picture>https://via.placeholder.com/640x480.png/003355?text=fugiat</picture>
  <picture>https://via.placeholder.com/640x480.png/006622?text=laudantium</picture>
  <picture>https://via.placeholder.com/640x480.png/00cc88?text=reiciendis</picture>
  <param name="Артикул">GD-WG&amp;$VS</param>
  <param name="Код цвета">7</param>
  <param name="Пол">female</param>
</offer>
<offer id="2" available="false" type="vendor.model">
  <url>https://example.com/products/distinctio-qui-ratione-consequatur-aspernatur-et</url>
  <barcode>GD-%L;]UB</barcode>
  <name>magnam consequatur harum cupiditate</name>
  <description>Harum in ratione perspiciatis quo consequatur id a. Totam magnam et est iusto amet totam minus voluptatum. In cum minima explicabo consectetur minus ex praesentium. Nemo maiores laboriosam dicta.</description>
  <delivery>true</delivery>
  <price>618</price>
  <currencyId>RUR</currencyId>
  <vendor>aut</vendor>
  <picture>https://via.placeholder.com/640x480.png/00bb77?text=aut</picture>
  <picture>https://via.placeholder.com/640x480.png/009933?text=voluptas</picture>
  <picture>https://via.placeholder.com/640x480.png/00eeee?text=delectus</picture>
  <param name="Артикул">GD-%L;]UB</param>
  <param name="Код цвета">5</param>
  <param name="Пол">male</param>
</offer>

</offers>
</shop>
</yml_catalog>
```