Bookmarks

Visitors can bookmark exhibitors, sessions, speakers, and booths, and find them later in the bookmarks list.

💡 Adding bookmarks is disabled in kiosk mode.

Bookmarks are not synced between devices

ExpoFP stores bookmarks only in the visitor's browser. To sync them, the map must run inside an app that knows the user. See Why bookmarks are not synced.

Bookmarking feature in the app interface

Desktop

Mobile

Where bookmarks are stored

The floor plan keeps bookmarks in the browser's localStorage, separately for each event. It does not send them to ExpoFP servers. Each browser therefore has its own list:

• A bookmark made on a phone does not appear on a laptop.
• Another browser, a private window, or a WebView inside a mobile app starts with an empty list.
• Clearing the browser's site data deletes the bookmarks.

Why bookmarks are not synced

A common question is: can a visitor's bookmarks follow them from device to device, or match their favorites in our event app?

ExpoFP cannot do this, and no setting will change it. The reason is in the architecture, not in a missing feature.

To sync bookmarks, a system must know whose bookmarks they are. An ExpoFP floor plan has no visitor accounts. Visitors open the map without signing in, and ExpoFP has no "map user": no login, no visitor ID, no profile. Without a user, there is nothing to attach a synced list to. Thus, there is nothing to sync.

Sync is possible when the map runs inside an application that already knows the user: an event app, an attendee portal, or a site with SSO. That application owns the user's identity, so it can also own the user's bookmarks. The JS SDK gives it everything it needs, and ExpoFP sets no limits on this:

• Put the user's bookmarks into the map with setEntitiesBookmarks.
• Get a notification when the user toggles a bookmark in the map with onBookmarkClick.

	Floor plan hosted by ExpoFP	Floor plan inside your app
Who is the user	Unknown (anonymous visitor)	Your signed-in user
Where bookmarks live	In that browser only	In your backend, the source of truth
Sync between devices	Not possible	Your app does it with the JS SDK

Bookmark management in the JS SDK

💡 See the JavaScript API Reference for details.

Adding and removing bookmarks

import { load } from 'https://unpkg.com/@expofp/floorplan';
load(
  { $ref: 'https://demo.expofp.com/manifest.json' },
  {
    element: document.querySelector('#floorplan'),
    onInit: (fp) => {
      // Save to bookmarks
      fp.setBookmarks([{ name: "Alaska Airlines", bookmarked: true }]);
      fp.setBookmarks([{ externalId: "bizx", bookmarked: true }]);
      // Remove from bookmarks
      fp.setBookmarks([{ name: "Alaska Airlines", bookmarked: false }]);
      fp.setBookmarks([{ externalId: "bizx", bookmarked: false }]);
    },
  },
);

setBookmarks works only with exhibitors. For sessions, speakers, and booths, use setEntitiesBookmarks and give each item a type:

import { load } from 'https://unpkg.com/@expofp/floorplan';
load(
  { $ref: 'https://demo.expofp.com/manifest.json' },
  {
    element: document.querySelector('#floorplan'),
    onInit: (fp) => {
      fp.setEntitiesBookmarks([
        { type: 'exhibitor', externalId: 'bizx', bookmarked: true },
        { type: 'event', name: 'Opening Keynote', bookmarked: true },
        { type: 'speaker', externalId: 'spk-42', bookmarked: false },
      ]);
    },
  },
);

Each item finds its entity by name or externalId (a slug also works). The call changes only the items you pass and keeps all other bookmarks as they are.

Responding when the user toggles bookmarks

Use onBookmarkClick when you need analytics, sync to your backend, or custom UI—not for the initial bookmark list passed at startup (still use onInit + setBookmarks, as above).

import { load } from 'https://unpkg.com/@expofp/floorplan';
load(
  { $ref: 'https://demo.expofp.com/manifest.json' },
  {
    element: document.querySelector('#floorplan'),
    onBookmarkClick: (e) => {
      // ...
    },
  },
);

What the SDK covers

Entity	Set from your app	onBookmarkClick when the user toggles it
Exhibitor	setBookmarks, or setEntitiesBookmarks with type: 'exhibitor'	Yes
Session	setEntitiesBookmarks with type: 'event'	Yes
Speaker	setEntitiesBookmarks with type: 'speaker'	No
Booth without exhibitors	setEntitiesBookmarks with type: 'booth'	No

Syncing bookmarks in your app

Keep the user's bookmarks in your backend and treat the map as a view of them:

1. Backend → map. When the map starts, load the user's bookmarks from your backend and apply them with setEntitiesBookmarks.
2. Map → backend. In onBookmarkClick, save each change to your backend.

import { load } from 'https://unpkg.com/@expofp/floorplan';

// `user` and `myApi` stand for your app's own sign-in and backend.
load(
  { $ref: 'https://demo.expofp.com/manifest.json' },
  {
    element: document.querySelector('#floorplan'),
    onInit: async (fp) => {
      // Backend → map. For example:
      // [{ type: 'exhibitor', externalId: 'bizx' }, { type: 'event', externalId: 'ses-7' }]
      const saved = await myApi.getBookmarks(user.id);
      if (saved.length) {
        fp.setEntitiesBookmarks(saved.map((b) => ({ ...b, bookmarked: true })));
      }
    },
    onBookmarkClick: (e) => {
      // Map → backend.
      myApi.saveBookmark(user.id, {
        name: e.name,
        externalId: e.externalId,
        bookmarked: e.bookmarked,
      });
    },
  },
);

Things to know

• The map also keeps its own copy of the bookmarks in the browser. To remove a bookmark that the user deleted on another device, pass it with bookmarked: false.
• onBookmarkClick fires only when the user clicks the bookmark button. Calls to setBookmarks and setEntitiesBookmarks do not fire it.
• The onBookmarkClick event has no entity type. To tell an exhibitor from a session, look up its externalId or name in your own data.
• Speaker and booth bookmarks that the user makes in the map do not fire onBookmarkClick, so they stay in the browser. If your app syncs only some entity types, you can hide the map's bookmark buttons with disableBookmarked and show bookmarks in your own UI.

Bookmarks and the URL

?bookmarks opens the bookmarks list on load. The bookmarks themselves have no URL form — they stay on the device that made them.