Supported networks 

Currently, fp_social supports the following social networks out of the box:

• Facebook

  • Import of posts from pages of which you are an administrator.

• Instagram

  • Your own profile
  • Recent posts as well as top posts of a hashtag

• Wordpress

  • All entries of a blog.
  • All entries that are tagged with a certain tag.
  • All entries of a specific author.

• Youtube

  • Latest entries of a profile.

• LinkedIn

  • Import of posts from pages of which you are an administrator.

• Bluesky

  • Import of posts from a profile.

Data protection 

In order to protect the visitors of your website from tracking by social networks, fp_social does not output the posts directly via the social networks.

The output of the posts works as follows:

• Posts are synchronized into the database of your TYPO3 instance according to the configured accounts.
• Data that is made available to the user is read from the TYPO3 instance and output.

This ensures that the social networks cannot store any cookies on the visitors' computers and that no tracking is possible either.

Requirements 

• TYPO3 v12.4, v13.4 or v14.4
• PHP 8.1 or higher (TYPO3 v14 requires PHP 8.3 or higher)

Setup 

Follow the steps below to set up the fp_social extension correctly.

1. Install the extension in your TYPO3 instance:

   • Composer (recommended): Require the extension via Composer:

     composer require fixpunkt/fp-social

     Copied!
   • Classic: Install the extension fp_social from the TYPO3 Extension Repository (TER) via the Extensions backend module.

2. Load the TypoScript configuration:

   • TYPO3 v13 and v14 (recommended): Assign the site set Social Wall (fixpunkt/fp-social) to your site. In the backend open Site Management > Sites, edit your site and add the set on the Sets tab, or declare it as a dependency in your site configuration:

     config/sites/<my-site>/config.yaml

     dependencies:
       - fixpunkt/fp-social

     Copied!
   • TYPO3 v12 (classic): Add the static template Social Wall (fp_social) to your TypoScript template record.
3. Set the TypoScript constants plugin.tx_fpsocial.persistence.storagePid and module.tx_fpsocial.persistence.storagePid.
4. Create your first access and social media account.
5. Create a Scheduler Task so that the stored social media accounts are synchronized automatically.

Creating accesses and accounts 

In order to access the social networks, you must define which access you want to use to reach which accounts.

Unfortunately, this is currently not yet possible via a backend module and must instead be done via the list module.

You can find the individual steps here.

Synchronizing accounts, managing and searching posts 

The backend module lets you conveniently perform various tasks:

• Manage accesses and accounts

  You manage accesses and accounts.

• Synchronize accounts and manage posts

  You can synchronize accounts, import posts, show and hide them, and choose the preview image for each post.

• Search posts

  You can search through posts that have already been imported.

• Manage synchronization

  The settings for automatic synchronization can be edited here. You can also configure what should happen with newly imported posts.

Establishing a connection with the SocialServer 

Communication with the respective social networks is handled through a bridge - the SocialServer.

To set up an access:

1. Create an account at http://social.fixpunkt.com and create an access token there. You may need to set up a subscription.

2. In your TYPO3 instance, switch to the List module and navigate to the folder in which you want to store the posts from the network.

   

3. Click "Create new record" and select fp_social > Credentials.

   

4. Enter your SocialServer username as well as the access token created in the first step.

   

5. Save your changes.

Setting up an account 

Once you have created an access, you can now create the account for which you want to use these access credentials.

To do so, proceed as follows:

1. Switch to the List module and navigate to the folder in which you want to store the posts from the network.

   

2. Click "Create new record" and select fp_social > Account.

   

3. Now fill in the fields as follows:

   • Basic data:

     • Network: The network from which you want to synchronize the account.
     • Credentials: The credentials created earlier.
     • Label: The display name of the account.
     • Additional fields: Depending on the selected network, further details must be provided. Click the label to get more guidance.

   • Synchronization:

     • Synchronize this account automatically: If this option is selected, the account is synchronized automatically (to learn how to set up automatic synchronization, see here).
     • Imported posts are published immediately: If this option is selected, all imported posts are published automatically (and thus visible in the frontend). Otherwise they must be published manually.
     • Date of the last synchronization: The point in time of the last synchronization attempt. Leave this field empty.
     • Date of the last successful synchronization: The point in time of the last successful synchronization. Leave this field empty.
   • Posts: Leave this field empty.

   

4. Save your changes.

List of all accounts 

Here you will find a list of all created accounts.

You can filter this list by type in the upper area of the table.

The following information is provided here:

• Network: The network from which the data is to be pulled.
• Mode: The account from which, and the mode in which, the data is read.
• Number of posts: The number of posts imported so far.
• Last synchronization: This shows you when the last attempt to synchronize the account was made. If this was not successful, the point in time of the last successful synchronization is also displayed, along with an error message.
• Next synchronization: This shows you the synchronization interval.

The following actions are possible:

• Synchronize: Synchronizes - depending on the social network - a certain number of the newest posts.
• Deep synchronization: Synchronizes the entire account. With the help of a wizard, all available posts are imported one after another.
• Show posts: Click here if you want to display all posts that have already been imported.

Account view 

In the account view you can see all posts imported with the account.

Here you have the following options:

• Preview images: If several preview images are available, you can select the current image as the preview image by clicking the respective image and the "Select this image as preview image" button.
• Show posts: By clicking "Open post" you can display the post in the relevant network.
• Show & hide: By clicking "Hide / show this post" you can hide or show the post in the frontend.
• Synchronize: By clicking "Re-synchronize post" you can re-import the post.

If you have deleted a post in the network, you can apply this deletion by re-synchronizing the post.

Automatic synchronization 

If this option is enabled, this account is taken into account during synchronization via the scheduler task. If this option is disabled, the account must be synchronized manually via the backend module.

Automatic publishing 

If this option is enabled, all imported posts are published automatically and displayed in the frontend. This option applies both to posts imported manually and to those imported with the help of the scheduler.

Settings 

Post

The post to be output. You can search by the Post Id.

Display of the Posts 

How the selected post is displayed can be adjusted via the settings described under Display of Posts.

Selection of the Posts 

Social Media Accounts

The accounts whose posts should be output.

Fixed Records

Individual posts that are always shown in the wall, independently of the selected accounts.

Restrict output to the following hashtags...

Filters the posts imported via the accounts by hashtags. Only posts that have at least one of the selected hashtags are shown. The filter is only taken into account if at least one hashtag is selected.

Number of Posts to Display 

The number of posts shown initially is the product of rows and columns.

Columns

Default: 1

The number of columns.

Rows

Default: 1

The number of rows.

Loading More 

Automatically load new records

Default: False

If this setting is enabled, posts that were created after the page was loaded are loaded automatically.

Replace older records with newer ones

Default: False

If this option is enabled, the oldest displayed post is removed when a new post is loaded automatically. This keeps the number of displayed posts the same and prevents the page from "jumping".

Allow manual loading of older records

Default: False

If this setting is enabled, a button is shown below the social wall that can be used to load additional, older posts. These increase the number of displayed posts and do not replace existing posts.

Label of the load button

The label of the button used to load additional, older posts.

Display of the Posts 

How the individual posts are displayed can be adjusted via the settings described under Display of Posts.

Available Tasks 

The following tasks are available to you:

• fp_social:synchronize: Synchronizes the created accounts if they are selected for automatic synchronization.

  • amount (optional): Number of social networks to synchronize. A value of 0 means no limit.

• fp_social:download: Downloads all post images that have not yet been downloaded. Otherwise this happens when the respective post is displayed for the first time.

  • amount (optional): Number of images to download. If no value is given, up to 40 images are downloaded.

• fp_social:remove: Deletes old posts that are older than the specified number of days and are not currently in use. Images that are no longer referenced (including the associated files) and hashtags are also removed in the process.

  • days (required): Number of days after which posts are deleted.

Setting up a Task 

1. Switch to the Scheduler module.
2. Click the button to add a new task.

3. Fill in the fields as follows:

   • Class: Execute console commands
   • Frequency: We recommend */15 * * * * here. This means that the task is executed every 15 minutes.
   • CommandController Command: Select one of the tasks listed above here.
4. Save the task and check it by running it manually once.

For more information about the Scheduler, see the official documentation.

Outputting information about the social network 

In the partials used to render a post (e. g. Post/Show, Post/Compact, Post/Extended as well as their components under Post/Parts), the associated account is available as the variable {account} alongside the post ({post}). This object can be used to output information about the social network – for example in the footer of a post (Post/Parts/Bottom).

The following properties are available on {account}:

<div class="socialhint">
    <i class="fab fa-fw {account.icon}"></i>
    <span>via {account.description}</span>
    <f:format.raw>{account.channelLink}</f:format.raw>
</div>

<a href="{account.channelUri}" target="_blank">@{account.label}</a>

How it works 

fp_social dispatches the PSR-14 event \Fixpunkt\FpSocial\Events\RecordCollectionEvent. An event listener in your extension registers a source by calling addSource() on the event:

$event->addSource(
    'myrecords',   // unique source identifier
    'myrecords',   // prefix used for collections (see "Identifier convention")
    'myrecords',   // prefix used for single records (see "Identifier convention")
    \Vendor\Extension\Social\RecordRepository::class
);

A source consists of three classes you provide:

• a repository implementing RecordRepositoryInterface that returns the selectable items for the backend and the actual records for the frontend,
• a record proxy implementing RecordInterface that adapts each of your records to the structure fp_social expects, and
• an account proxy extending \Fixpunkt\FpSocial\Domain\Model\Account that provides the meta information (label, icon, …) shown for the records.

Identifier convention 

Records and collections are referenced as strings of the form <prefix>:<uid>, e.g. myrecords:42. The second and third argument of addSource() define the prefixes fp_social uses to recognize which entries belong to your source. fp_social strips the prefix and passes the bare uids to your repository.

• Collections are the entries shown in the Social media accounts field of the Wall plugin. Use them to let editors choose which set of records is output (for example a category).
• Records are individual entries shown in the Fixed records field of the Wall plugin and in the single Post field of the Plugin "Output Post" plugin.

Step 1: The record proxy 

Implement \Fixpunkt\FpSocial\Domain\Interfaces\RecordInterface to wrap a single record of your extension:

<?php
namespace Vendor\Extension\Social;

use Fixpunkt\FpSocial\Domain\Interfaces\RecordInterface;
use Fixpunkt\FpSocial\Domain\Model\Account;
use Fixpunkt\FpSocial\Domain\Model\Picture;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Persistence\ObjectStorage;

class RecordProxy implements RecordInterface
{
    public function __construct(private readonly MyRecord $record) {}

    public function getIdentifier(): string { return 'myrecords:' . $this->record->getUid(); }
    public function getId(): string { return (string)$this->record->getUid(); }
    public function getNetwork(): string { return 'My records'; }
    public function getAccount(): Account { return GeneralUtility::makeInstance(AccountProxy::class); }
    public function getUrl(): string { return $this->buildDetailUri(); }
    public function getLink(): string { return $this->getUrl(); }
    public function getUpdatedTime() { return $this->record->getDatetime(); } // must be a \DateTime
    public function getHeadline(): string { return $this->record->getTitle(); }
    public function getMessage(): string { return $this->record->getText(); }
    public function getPicture(): string { return ''; } // URL of the preview image

    public function getPictures()
    {
        $pictures = new ObjectStorage();
        if ($this->record->getImage()) {
            $picture = new Picture();
            $picture->setFileReference($this->record->getImage());
            $pictures->attach($picture);
        }
        return $pictures;
    }

    public function getSelectedOrFirstPicture() { return $this->getPictures()->current(); }
    public function asJson(): array { return []; }
}

A few notes:

• getUpdatedTime() must return a \DateTime. It is used to sort the records across all sources and to drive the pagination of the wall.
• getPictures() returns an ObjectStorage of \Fixpunkt\FpSocial\Domain\Model\Picture objects; attach a sys_file_reference to each via setFileReference().
• asJson() is only used for the AJAX output and may return an empty array.

Step 2: The account proxy 

The post templates render meta information (source name, icon, link, partial folder) through the record's account. Provide an account proxy by extending the abstract Account model:

<?php
namespace Vendor\Extension\Social;

use Fixpunkt\FpSocial\Domain\Model\Account;
use TYPO3\CMS\Core\SingletonInterface;

class AccountProxy extends Account implements SingletonInterface
{
    public static function getDescription(): string { return 'My records'; }
    public static function getPartialFolder(): string { return 'MyRecords'; }

    public function getChannelUri(): string { return ''; }
    public function getChannelLink(): string { return ''; }
    public static function getPictureIdentifier(string $uri): string { return $uri; }
    public static function getTCALabelAccount(int $uid): string { return ''; }
}

getDescription() is shown as the source label (for example in the post footer), and getPartialFolder() controls the CSS class and template variant used when rendering the record. The remaining abstract methods can return empty values if they are not relevant for your records.

Step 3: The record repository 

Implement \Fixpunkt\FpSocial\Domain\Interfaces\RecordRepositoryInterface with four methods – two for the backend selection and two for the frontend output:

<?php
namespace Vendor\Extension\Social;

use Fixpunkt\FpSocial\Domain\Interfaces\RecordInterface;
use Fixpunkt\FpSocial\Domain\Interfaces\RecordRepositoryInterface;

class RecordRepository implements RecordRepositoryInterface
{
    // Backend: entries for the "Social media accounts" field.
    public function getCollectionsForTca(): array
    {
        return [
            ['label' => 'My records', 'value' => 'myrecords:1'],
        ];
    }

    // Backend: entries for the "Fixed records" and single "Post" fields.
    public function getAllRecordsForTca(): array
    {
        $items = [];
        foreach ($this->findAll() as $record) {
            $items[] = [
                'label' => 'My record: ' . $record->getTitle(),
                'value' => 'myrecords:' . $record->getUid(),
            ];
        }
        return $items;
    }

    // Frontend: load specific records by their (prefix-stripped) uids.
    public function getRecordsByIdentifiers(array $identifiers): array
    {
        $records = [];
        foreach ($this->findByUids($identifiers) as $record) {
            $records[] = new RecordProxy($record);
        }
        return $records;
    }

    // Frontend: load records for the wall, honoring filter, limit and pagination.
    public function getRecordsByFilter(array $filter, int $limit, ?RecordInterface $referenceRecord): array
    {
        // $filter['collectionIdentifiers']        selected collection ids of this source
        // $filter['preselectedRecordIdentifiers'] uids already shown as fixed records (exclude them)
        // $filter['hashtags']                     selected hashtag uids (ignore if not applicable)
        // $filter['order']                        QueryInterface::ORDER_DESCENDING | ORDER_ASCENDING
        // $referenceRecord                        load records older/newer than this one (pagination)
        $records = [];
        foreach ($this->query($filter, $limit, $referenceRecord) as $record) {
            $records[] = new RecordProxy($record);
        }
        return $records;
    }
}

In getRecordsByFilter() you should:

• exclude the uids in $filter['preselectedRecordIdentifiers'] (they are already output as fixed records),
• order the records by date according to $filter['order'],
• respect $limit, and
• when $referenceRecord is given, only return records that are older (for ORDER_DESCENDING) or newer than $referenceRecord->getUpdatedTime() – this drives the "load more" and "load newer" functionality.

fp_social merges and re-sorts the records of all sources by getUpdatedTime() afterwards.

Step 4: Register the source 

Create an event listener for the RecordCollectionEvent and register it as a service.

<?php
namespace Vendor\Extension\EventListener;

use Fixpunkt\FpSocial\Events\RecordCollectionEvent;
use Vendor\Extension\Social\RecordRepository;

final class RegisterRecordSource
{
    public function __invoke(RecordCollectionEvent $event): void
    {
        $event->addSource('myrecords', 'myrecords', 'myrecords', RecordRepository::class);
    }
}

# Configuration/Services.yaml
services:
  _defaults:
    autowire: true
    autoconfigure: true
    public: true

  Vendor\Extension\:
    resource: '../Classes/*'
    exclude: '../Classes/Social/*'

  Vendor\Extension\EventListener\RegisterRecordSource:
    tags:
      - name: event.listener
        identifier: 'myextension-fpsocial-recordsource'

Result 

Once the source is registered, your records become selectable in the Wall plugin: as a collection under Social media accounts and individually under Fixed records. Single records can also be output with the Plugin "Output Post" plugin. In the frontend they are rendered with the standard post templates, merged with the social media posts and sorted by date.

Authentication 

All requests to the Social Server are POST requests to the respective endpoint URL. This URL is composed of the configured apiUrl and the path of the endpoint, e. g.:

https://my-server.example.com/api/ + networks/facebook/posts

The parameters are passed as form_params (application/x-www-form-urlencoded). In addition to the endpoint-specific parameters, every request contains the following fields:

The server is responsible for verifying auth[username] and auth[accesstoken]. With your own server, you assign these credentials yourself.

Expected response format 

The server's response must be a JSON that can be deserialized by the extension, with the help of the extension fixpunkt/fp-social-bridge, into one of the following response objects:

The individual posts are expected as objects of type Fixpunkt\FpSocialBridge\v2\Data\Post.

Endpoints 

For each network, endpoints are needed for reading a list of posts as well as for reading a single post. Each endpoint is described individually below.

The JSON examples each show the complete POST body including the version and auth fields described under Authentication, so they can be copied directly. Depending on the endpoint, the response is expected to be either a list of posts (SocialServerPostsResponse) or a single post (SocialServerPostResponse); the exact format is described in the section Expected response format.

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "pageId": "Facebook page ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "postId": "Post ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "pageId": "Instagram profile ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "pageId": "Instagram profile ID",
    "hashtag": "fixpunkt",
    "mode": "recent_media"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "postId": "Post ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "pageId": "LinkedIn page ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "pageId": "LinkedIn page ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "postId": "Post ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "channel": "YouTube channel ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "videoId": "Video ID"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "baseUrl": "https://my-blog.example.com"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "baseUrl": "https://my-blog.example.com",
    "tag": "Tag"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "baseUrl": "https://my-blog.example.com",
    "author": "Author"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "postId": "Post ID",
    "baseUrl": "https://my-blog.example.com"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "clientHandle": "profil.bsky.social"
}

{
    "version": 2,
    "auth": {
        "username": "Your username",
        "accesstoken": "Your access token"
    },
    "uri": "at://…"
}

Unreleased 

• Added compatibility with TYPO3 v14. The extension now supports TYPO3 v12.4, v13.4 and v14.4.
• For TYPO3 v13 and v14 the TypoScript can now be loaded via the site set Social Wall (fixpunkt/fp-social). The static template remains available for TYPO3 v12. See Installation.
• Removed usage of APIs that were deprecated or removed in TYPO3 v14.