> ## Content Index
> Fetch the complete content index at: https://blog.esadax.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Pixelfed
- URL: https://blog.esadax.com/en/pixelfed-en-8/
- Published: 2026-11-15T05:09:43.000Z
- Updated: 2026-11-15T05:09:43.000Z
- Author: Esadax 
- Tags: #tr-apps-03-catalog-pixelfed, #en, #mdx-imported, Apps

# What is Pixelfed?

Pixelfed is a decentralized, open-source photo-sharing platform designed for sharing photographs, discovering creative content, and interacting with other users across a federated social network.

Built around the ActivityPub protocol, Pixelfed allows users to create accounts, publish photographs, share albums, follow other users, and interact with content from different compatible platforms in the Fediverse.

Unlike centralized social media platforms, Pixelfed allows individuals and organizations to operate their own independent servers while remaining connected to a broader decentralized network.

It provides a familiar social media experience with photo posts, captions, hashtags, likes, comments, collections, and user profiles, without requiring users to depend on a single centralized service.

Pixelfed is particularly suitable for photographers, creative communities, privacy-conscious users, and organizations looking to operate their own decentralized photo-sharing communities.

## History of Pixelfed

Pixelfed was created by Daniel Supernault (dansup) as an open-source alternative to centralized photo-sharing platforms.

The project focuses on providing a decentralized social networking experience built around photography and visual content.

By adopting ActivityPub, Pixelfed allows independently operated servers to communicate with one another and exchange social activities.

This interoperability enables users to follow accounts hosted on different servers and interact with their posts without requiring accounts on the same instance.

Pixelfed is developed primarily using PHP and Laravel, with a web interface and supporting services for media processing, caching, and background jobs.

The project is distributed under the GNU Affero General Public License (AGPL).

## Key Features of Pixelfed

Pixelfed provides a collection of social networking and photo management features.

- **Photo Sharing:** Publish photographs and visual content through personal or organizational accounts.
- **Albums:** Combine multiple photographs into a single post.
- **ActivityPub Federation:** Interact with users and content from other compatible Fediverse platforms.
- **User Profiles:** Create customizable profiles with biographies, profile pictures, and published posts.
- **Following and Followers:** Follow other accounts and build a personalized social network.
- **Likes and Comments:** Interact with photographs through likes and comments.
- **Hashtags:** Categorize and discover content using hashtags.
- **Content Discovery:** Explore public photographs and discover new creators.
- **Media Filters:** Apply visual adjustments and filters to photographs before publishing.
- **Stories:** Share temporary visual content using supported Story functionality.
- **Collections:** Organize and save photographs into personal collections.
- **Content Warnings:** Mark sensitive content so that media can be concealed before viewing.
- **Alt Text:** Add accessibility descriptions to photographs.
- **Geolocation:** Associate geographical information with published photographs.
- **Privacy Controls:** Configure account and post visibility.
- **Moderation Tools:** Block, mute, report, and manage unwanted interactions.
- **Mobile Access:** Use compatible mobile applications and browser interfaces.
- **REST API:** Integrate external applications with supported Pixelfed functionality.
- **OAuth Support:** Allow compatible applications to authenticate through the platform.
- **Docker Deployment:** Host the application using Docker Compose.

## Use Cases

Pixelfed is suitable for individuals, photographers, communities, and organizations interested in decentralized photo sharing.

Common use cases include:

- **Photography Communities:** Build communities where photographers can publish and share their work.
- **Personal Photo Sharing:** Share everyday photographs with followers and friends.
- **Creative Portfolios:** Publish photography, illustrations, and other visual content.
- **Decentralized Social Networks:** Operate an independent photo-sharing instance connected to the Fediverse.
- **Community Platforms:** Create dedicated spaces for photography enthusiasts and creative groups.
- **Travel Photography:** Share photographs, travel experiences, and geographical discoveries.
- **Artistic Communities:** Build communities focused on visual arts and creative expression.
- **Private Communities:** Operate invite-controlled instances for selected users.
- **Open Social Networking:** Interact with users across Pixelfed, Mastodon, and other compatible ActivityPub platforms.
- **Self-Hosted Media Communities:** Maintain control over community infrastructure and uploaded photographs.

## Benefits of Pixelfed

- Open-source and self-hosted photo-sharing platform
- Decentralized social networking through ActivityPub
- Interoperability with compatible Fediverse platforms
- Independent server and community administration
- Photo posts and multi-image albums
- Hashtags and content discovery
- User profiles and social interactions
- Privacy and visibility controls
- Content warnings and accessibility descriptions
- Stories and media collections
- Moderation and account management
- REST API and OAuth integration
- Configurable media storage
- Docker-based deployment
- Greater control over community data and infrastructure

## How to Install Pixelfed

To install Pixelfed through Esadax, follow these steps:

1. Purchase the application through Esadax.
2. After purchasing, you will be prompted to provide the required configuration parameters.
3. Configure the public domain that will identify your Pixelfed instance.
4. Configure the database connection and credentials.
5. Configure Redis for caching and background jobs.
6. Generate and configure the application encryption key.
7. Configure SMTP settings for account registration and notifications.
8. Configure persistent storage for uploaded photographs and videos.
9. Enable ActivityPub federation if the instance should communicate with the Fediverse.
10. Click **Deploy** to launch Pixelfed.
11. Access Pixelfed through its assigned application URL.
12. Complete the initial administrator and instance setup.
13. Configure registration policies and moderation settings.
14. Create your user account and customize your profile.
15. Start publishing photographs and interacting with other federated communities.

Once configured, Pixelfed provides a self-hosted social networking platform for sharing photographs and connecting with the wider Fediverse.

## Photo and Album Management

Pixelfed is primarily designed around photo sharing.

Users can publish individual photographs or combine multiple images into albums.

Each publication can include descriptive text, hashtags, mentions, accessibility descriptions, and other supported metadata.

Photo management capabilities include:

- Uploading photographs
- Publishing multi-image albums
- Adding captions and descriptions
- Applying supported image filters
- Adding hashtags and mentions
- Setting content warnings
- Adding alternative text
- Associating location information
- Managing published posts
- Deleting or editing content

Albums provide a convenient way to publish several related photographs together.

For example, a photographer can create an album containing images from a particular event, location, or photography project.

## ActivityPub and Fediverse Federation

One of Pixelfed's most important features is its integration with ActivityPub.

ActivityPub is an open social networking protocol that allows independently operated platforms to communicate with one another.

Pixelfed uses this protocol to exchange activities with compatible applications such as Mastodon and other Fediverse software.

Federation allows users to:

- Follow accounts hosted on other servers.
- Receive posts from remote accounts.
- Share photographs with remote followers.
- Like and comment on federated posts.
- Re-share supported content.
- Discover users from other instances.
- Receive follower requests.
- Maintain social connections across independent servers.

For example, a Pixelfed user can follow a Mastodon account without creating a separate Mastodon account.

Similarly, users on compatible platforms can follow Pixelfed accounts using their federated addresses.

An account generally follows the format:

`@username@example.com`

The domain identifies the server hosting the account.

Federation allows each server to maintain its own administration, registration policies, and moderation rules while remaining part of a larger decentralized network.

## User Profiles and Social Interaction

Pixelfed provides user profiles for publishing photographs and building social connections.

Each account has a profile page containing information such as:

- Username
- Display name
- Profile picture
- Biography
- Published photographs
- Albums
- Followers
- Following information

Users can follow other accounts, interact with their publications, and build their own social networks.

The platform provides several interaction mechanisms:

- Liking photographs
- Commenting on posts
- Following accounts
- Mentioning other users
- Sharing supported publications
- Discovering accounts through search and hashtags

These features create a familiar social experience while maintaining compatibility with decentralized networking standards.

## Content Discovery and Hashtags

Pixelfed includes discovery functionality for browsing photographs and finding accounts.

Hashtags provide a way to categorize visual content and help users discover publications related to specific subjects.

Examples include:

- `#photography`
- `#landscape`
- `#architecture`
- `#streetphotography`
- `#nature`
- `#travel`

Users can search for hashtags and explore content published by different accounts.

Public content discovery also allows users to find photographers and communities outside their existing list of followers.

The visibility of federated content depends on account privacy settings, publication visibility, moderation policies, and server federation behavior.

## Stories and Temporary Content

Pixelfed supports Stories for sharing temporary visual content.

Stories provide a different publishing experience from permanent photo posts.

They are useful for:

- Behind-the-scenes photographs
- Daily updates
- Travel moments
- Short visual announcements
- Informal community interactions

Pixelfed also implements ActivityPub extensions for exchanging supported Story activities.

Story federation is not universal across all compatible platforms and is currently supported primarily between known Pixelfed instances.

## Privacy and Visibility Controls

Pixelfed provides privacy controls that allow users to manage the visibility of their accounts and publications.

Depending on the supported settings, users can configure:

- Public account visibility
- Private accounts requiring follower approval
- Publication visibility
- Follower access
- Content warnings
- Comment permissions
- Account blocking and muting

Private accounts require users to approve incoming follow requests before their followers can access protected content.

Content warnings allow potentially sensitive media to be concealed behind an additional action.

Users should understand that publishing content publicly or sharing it with federated servers can result in copies being cached or distributed outside their original instance.

Deleting a post from the originating server does not guarantee immediate deletion of every remote copy.

## Federation with Mastodon and Other Platforms

Pixelfed is part of the wider Fediverse, a network of independently operated social platforms that communicate through open protocols.

ActivityPub interoperability makes it possible to interact with users across different applications.

Compatible platforms include:

- **Mastodon:** Follow accounts, view supported posts, and interact with federated content.
- **Other Pixelfed Instances:** Exchange photographs, followers, and social activities.
- **Other ActivityPub Platforms:** Interact with compatible services according to their protocol implementations.

Federation also introduces administrative responsibilities.

Instance administrators can establish community policies, moderate local users, and manage interactions with remote servers.

An administrator can block specific remote instances when their content or moderation policies conflict with the local community's requirements.

## API and Developer Integrations

Pixelfed provides API functionality that allows compatible applications to interact with the platform.

Its API is based on Mastodon-compatible endpoints and Pixelfed-specific functionality.

Common integration scenarios include:

- Authenticating external applications.
- Publishing photographs programmatically.
- Retrieving account information.
- Accessing supported timelines.
- Managing social interactions.
- Integrating photo publishing into external applications.
- Developing custom clients.
- Automating supported account operations.

Pixelfed also supports OAuth authentication for external applications.

API access can be configured according to the instance's authentication settings and application permissions.

For production deployments, protect API credentials and restrict access to authorized applications.

## Media Processing and Storage

Pixelfed processes uploaded photographs and videos before making them available through the platform.

Media processing can include:

- Image resizing
- Thumbnail generation
- Image optimization
- Metadata extraction
- Format validation
- Video thumbnail generation
- Media storage and delivery

The application supports different image-processing drivers, including:

- libvips
- GD
- ImageMagick

The selected image driver affects processing capabilities and performance.

Pixelfed also supports compatible cloud storage services through its filesystem configuration.

For larger instances, external S3-compatible object storage can reduce the amount of media data maintained directly on the application server.

## Security / Administration / Configuration

Pixelfed provides administration and moderation functionality for managing users, registration, media, and instance behavior.

Because a federated photo-sharing instance handles personal information and publicly distributed media, appropriate security controls are essential.

Important security practices include:

- Use strong administrator credentials.
- Generate a unique application encryption key.
- Enable HTTPS for all public access.
- Set `APP_DEBUG` to `false` in production.
- Protect database credentials.
- Secure Redis access.
- Restrict administrative functionality.
- Configure registration policies carefully.
- Enable email verification when appropriate.
- Monitor user reports and moderation activity.
- Configure trusted proxies correctly.
- Protect media storage and database backups.
- Keep Pixelfed and its dependencies updated.
- Review federation and remote-instance policies.
- Restrict public registration when operating a private community.

The instance domain should be selected before launching federation.

Changing the canonical domain after accounts and posts have been federated can create problems with account identities, media URLs, and remote references.

Administrators should also understand that federated content may be replicated and cached by remote servers.

## Best Practices for Pixelfed

- Choose a stable domain for the instance before deployment.
- Configure HTTPS for the application.
- Generate and securely back up `APP_KEY`.
- Enable ActivityPub only when federation is intended.
- Configure Redis for caching and background job processing.
- Run the queue worker and scheduler continuously.
- Configure SMTP for account verification and notifications.
- Set reasonable upload size limits.
- Use persistent storage for media files.
- Consider S3-compatible storage for larger instances.
- Establish clear community guidelines.
- Review registration and moderation policies.
- Monitor federation activity and failed background jobs.
- Back up the database and uploaded media.
- Keep the application and image-processing components updated.
- Test upgrades before applying them to production.

## Configuration Parameters

After purchasing this application on **Esadax**, you will be prompted to provide the configuration parameters required by the deployment.

Pixelfed uses environment variables, generally defined in a `.env` file, to configure the application and supporting services.

The following parameters are based on the upstream Docker configuration.

### Application Configuration

| Parameter                    | Description                                                               |
| ---------------------------- | ------------------------------------------------------------------------- |
| APP\_NAME                    | Name displayed by the Pixelfed instance.                                  |
| APP\_ENV                     | Application environment, normally production.                             |
| APP\_KEY                     | Unique application encryption key generated during initialization.        |
| APP\_DEBUG                   | Enables or disables application debugging. Should be false in production. |
| APP\_LOCALE                  | Default application language.                                             |
| APP\_URL                     | Complete public URL of the Pixelfed instance, including HTTPS.            |
| APP\_DOMAIN                  | Primary domain used by the instance.                                      |
| ADMIN\_DOMAIN                | Domain configured for administrative application access.                  |
| SESSION\_DOMAIN              | Domain used for session cookies.                                          |
| OPEN\_REGISTRATION           | Controls whether new users can register accounts.                         |
| ENFORCE\_EMAIL\_VERIFICATION | Requires email verification during registration.                          |
| PF\_MAX\_USERS               | Maximum number of users permitted by the instance configuration.          |
| PF\_MIN\_REGISTRATION\_AGE   | Minimum age configured for new registrations.                             |
| INSTANCE\_DISCOVER\_PUBLIC   | Controls public instance discovery.                                       |

### Database Configuration

Pixelfed uses a relational database to store accounts, posts, interactions, and application information.

| Parameter          | Description                                                                             |
| ------------------ | --------------------------------------------------------------------------------------- |
| DB\_CONNECTION     | Database driver, normally mysql.                                                        |
| DB\_HOST           | Database server hostname.                                                               |
| DB\_PORT           | Database server port.                                                                   |
| DB\_DATABASE       | Database name.                                                                          |
| DB\_USERNAME       | Database username.                                                                      |
| DB\_PASSWORD       | Database password.                                                                      |
| DB\_ROOT\_PASSWORD | Root password for the database service when using the supplied Docker Compose database. |

The official Docker configuration uses MySQL.

Current upstream support includes MySQL 8+ and MariaDB 11+. PostgreSQL 14+ is listed as best-effort support and is not recommended for production.

### Redis and Queue Configuration

| Parameter       | Description                                       |
| --------------- | ------------------------------------------------- |
| REDIS\_CLIENT   | Redis client implementation.                      |
| REDIS\_SCHEME   | Redis connection scheme, normally tcp.            |
| REDIS\_HOST     | Redis server hostname.                            |
| REDIS\_PORT     | Redis server port.                                |
| REDIS\_PASSWORD | Redis authentication password.                    |
| SESSION\_DRIVER | Storage backend used for application sessions.    |
| CACHE\_STORE    | Cache backend, normally redis.                    |
| QUEUE\_DRIVER   | Background job queue backend, normally redis.     |
| HORIZON\_PREFIX | Prefix used for Laravel Horizon queue monitoring. |

### ActivityPub and Federation

| Parameter          | Description                                 |
| ------------------ | ------------------------------------------- |
| ACTIVITY\_PUB      | Enables or disables ActivityPub federation. |
| AP\_REMOTE\_FOLLOW | Enables remote account following.           |
| AP\_INBOX          | Enables ActivityPub inbox processing.       |
| AP\_OUTBOX         | Enables ActivityPub outbox functionality.   |
| AP\_SHAREDINBOX    | Enables shared inbox processing.            |

These settings should be configured according to whether the instance is intended to participate in the Fediverse.

### Media Configuration

| Parameter            | Description                                                   |
| -------------------- | ------------------------------------------------------------- |
| IMAGE\_DRIVER        | Image-processing driver: vips, gd, or imagick.                |
| PF\_OPTIMIZE\_IMAGES | Enables image optimization.                                   |
| IMAGE\_QUALITY       | Default image optimization quality.                           |
| MAX\_PHOTO\_SIZE     | Maximum configured photo upload size.                         |
| MAX\_CAPTION\_LENGTH | Maximum length of photo captions.                             |
| MAX\_ALBUM\_LENGTH   | Maximum number of media attachments permitted in an album.    |
| MEDIA\_TYPES         | Accepted standard media MIME types.                           |
| MODERN\_MEDIA\_TYPES | Accepted modern image formats, depending on the image driver. |

### Email Configuration

| Parameter           | Description                              |
| ------------------- | ---------------------------------------- |
| MAIL\_DRIVER        | Email delivery driver, normally smtp.    |
| MAIL\_HOST          | SMTP server hostname.                    |
| MAIL\_PORT          | SMTP server port.                        |
| MAIL\_USERNAME      | SMTP authentication username.            |
| MAIL\_PASSWORD      | SMTP authentication password.            |
| MAIL\_ENCRYPTION    | SMTP connection encryption, such as tls. |
| MAIL\_FROM\_ADDRESS | Sender email address.                    |
| MAIL\_FROM\_NAME    | Sender display name.                     |
| MAIL\_AUTO\_TLS     | Controls automatic STARTTLS negotiation. |

### External Storage Configuration

Pixelfed supports external object storage through compatible S3 services.

| Parameter                       | Description                                     |
| ------------------------------- | ----------------------------------------------- |
| PF\_ENABLE\_CLOUD               | Enables cloud storage integration.              |
| FILESYSTEM\_CLOUD               | Filesystem storage backend, normally s3.        |
| AWS\_ACCESS\_KEY\_ID            | Object storage access key.                      |
| AWS\_SECRET\_ACCESS\_KEY        | Object storage secret key.                      |
| AWS\_DEFAULT\_REGION            | Object storage region.                          |
| AWS\_BUCKET                     | Name of the storage bucket.                     |
| AWS\_URL                        | Public storage URL when configured.             |
| AWS\_ENDPOINT                   | S3-compatible storage endpoint.                 |
| AWS\_USE\_PATH\_STYLE\_ENDPOINT | Enables path-style S3 addressing when required. |

The exact configuration parameters depend on the Esadax deployment package. Use the values presented during the purchase and deployment process.

Generate a secure `APP_KEY` during initial installation and preserve it across upgrades and container replacements.

Once the required values are configured, click **Deploy** to launch Pixelfed.

## Database and Storage

Pixelfed relies on several supporting services to operate a federated photo-sharing instance.

The main components include:

- **Application:** Handles user accounts, posts, profiles, and API requests.
- **MySQL or MariaDB:** Stores users, posts, comments, relationships, and application metadata.
- **Redis:** Provides caching and background job queue functionality.
- **Horizon:** Processes background jobs, including media processing and federation delivery.
- **Scheduler:** Executes scheduled application tasks.
- **Persistent Storage:** Stores uploaded photographs, videos, generated thumbnails, and application files.

The official Docker Compose deployment includes separate application, Horizon, scheduler, database, and Redis services.

The application storage directory is mounted at:

`/var/www/html/storage`

Ensure that this directory is persistent so uploaded media and application files are not lost when containers are recreated.

For reliable operation:

- Use persistent storage for application media.
- Configure persistent MySQL or MariaDB storage.
- Preserve Redis data where required by the deployment.
- Back up the database regularly.
- Include uploaded media and generated application files in backups.
- Protect application secrets and configuration files.
- Monitor storage consumption and database performance.
- Test restoration procedures.

## Background Processing and Scalability

Pixelfed relies heavily on background jobs to process media and exchange federated activities.

The Laravel Horizon worker processes jobs such as:

- Image and video optimization
- Thumbnail generation
- Media imports
- Remote post delivery
- Federation inbox processing
- Timeline updates
- Follower notifications
- Account maintenance

A separate scheduler service executes recurring application tasks.

These services should remain operational for reliable production deployments.

The official Docker Compose configuration separates the web application, Horizon worker, and scheduler into individual containers.

For larger instances, administrators can adjust queue worker concurrency according to server resources and activity levels.

Performance depends on the number of users, uploaded media, federation activity, image-processing requirements, and database workload.

## ActivityPub Federation and Network Requirements

A publicly federated Pixelfed instance requires a stable public domain and working external connectivity.

For federation to work correctly:

- Configure a valid public HTTPS URL.
- Ensure DNS records resolve to the server.
- Allow external HTTPS requests.
- Configure the reverse proxy to forward requests correctly.
- Set the canonical application domain.
- Enable the required ActivityPub settings.
- Ensure background queue workers are running.
- Configure the instance actor during initial setup.

Federation uses ActivityPub endpoints to exchange activities between servers.

Unlike a private photo gallery, a federated instance must remain reachable by other servers so that remote accounts can retrieve profiles, discover posts, and deliver interactions.

A private instance can still use Pixelfed without public federation, but it will not provide the same decentralized social networking experience.

## Conclusion

Pixelfed is a decentralized, open-source photo-sharing platform designed to give individuals and organizations control over their own social networking infrastructure.

With photo publishing, albums, hashtags, social interactions, privacy controls, and ActivityPub federation, it provides a modern alternative to centralized photo-sharing platforms.

Its ability to communicate with Mastodon and other compatible Fediverse services makes it particularly useful for building independent photography communities without sacrificing interoperability.

With Docker-based deployment, configurable media storage, background processing, and community administration tools, Pixelfed is a practical solution for anyone looking to operate a self-hosted and decentralized photo-sharing service.

## Official Resources

- [Pixelfed Official Website](https://pixelfed.org/?ref=blog.esadax.com)
- [Documentation](https://pixelfed.github.io/docs-next/?ref=blog.esadax.com)
- [GitHub Repository](https://github.com/pixelfed/pixelfed?ref=blog.esadax.com)
- [Docker Compose Configuration](https://github.com/pixelfed/pixelfed/blob/dev/docker-compose.yml?ref=blog.esadax.com)
- [Docker Environment Configuration](https://github.com/pixelfed/pixelfed/blob/dev/.env.docker.example?ref=blog.esadax.com)
- [Installation Guide](https://pixelfed.github.io/docs-next/running-pixelfed/installation.html?ref=blog.esadax.com)
- [Prerequisites](https://pixelfed.github.io/docs-next/running-pixelfed/prerequisites.html?ref=blog.esadax.com)
- [Configuration Reference](https://pixelfed.github.io/docs-next/running-pixelfed/configuration.html?ref=blog.esadax.com)
- [ActivityPub Documentation](https://pixelfed.github.io/docs-next/spec/ActivityPub.html?ref=blog.esadax.com)