Import and integration overview

Guide

Introduction

Fibery is an all-in-one work management tool, but there are instances where you may need to connect it to other systems for data import or integration.

Understanding the distinctions between import, integration, and two-way sync is crucial in deciding the best approach for connecting Fibery with external systems.

Import

Importing data allows users to bring data from external sources into Fibery, saving time and effort. It can be a one-time process, and the imported data remains static until another import is performed.

Two types of import exist: file-based and API-based.

File-based import

File-based import allows importing data from external sources as files. This method is straightforward and can be useful for importing data from legacy systems or from other tools that don't have direct integration with Fibery. However, it is important to note that the quality of the imported data depends on the quality of the original data and how well it is organized.

API-based import

API-based import allows importing data from external sources using the third-party tool's public API. This method is more powerful and flexible than file-based import, as it allows for more control over the import process and can handle more complex data structures.

However, the quality, accessibility, and reliability of the third-party API will define the import quality. We add many extra logic and configuration options to help maximize the data transfer when importing data. These options can help ensure that the imported data is accurate, complete, and organized in a way that makes sense for your use case.

Integration

Integrating Fibery with external tools or services allows you to collaborate with data created outside of Fibery. Integrations enable a connection of other tools and services like Slack, GitLab, or Hubspot and sync their data into Fibery. Integrations use the same third-party public API described in the Import section above.

Integration is unidirectional. Integrations are set up once and run automatically or manually in the background to get fresh information.

Integration is typically used for the following use cases:

Streamlining workflows: Integrating Fibery with other tools can help to streamline workflows by automating repetitive tasks or eliminating the need for manual data entry.
For example, you could integrate Fibery with a project management tool to automatically create tasks in Fibery when a new project is created in the other tool.
Data aggregation: Integrating Fibery with other data sources can help to consolidate information in one place, making it easier to analyze and work with.
For example, you could integrate Fibery with a customer relationship management (CRM) tool to pull in customer data and use it to inform product development decisions.
Custom integrations: Integrating Fibery with custom-built tools or systems can help to create tailored solutions for specific use cases or industries or enhance functionalities.
For example, custom integrations can pull data from IoT devices and sensors into Fibery for analysis and action.

For more details, please check Integration templates and Create Custom Integrations.

When creating a Database, you can also import or sync data from an external source:

Select how to import users from other tools

When importing or syncing data from your ~~current~~ previous 😈 tools (e.g. Notion or ClickUp), select how (and whether) to bring the users in:

When importing or syncing data from external tools (e.g. Notion, ClickUp), you can decide how to handle users.

You have three options:

Invite as Fibery Users
- Missing users will be invited directly into your Fibery workspace.
- You can choose whether to notify them by email.
- By default, new users are invited as Observers, which does not affect billing since Observers and Guests are free.
Sync as a Separate User Database
- Users are imported as a standalone database (e.g. “Members”) inside Fibery.
- This option is useful if you want to reference users as entities without inviting them to your workspace.
Skip Users
- Users are ignored during import.

If you only want real collaboration, choose Invite. If you just need to keep records, use Sync.

Two-way sync

Two-way sync allows for bi-directional data exchange between Fibery and an external tool or service. With two-way sync, any updates made to data in Fibery are automatically reflected in the external system and vice versa. This ensures that all data across the two systems is always up to date.

Two-way sync is typically used for the following use cases:

High-value data sync: This can be data such as customer records or financial data, where discrepancies or inconsistencies can have serious consequences.
Collaboration between different teams: When two different teams in an organization use different tools, two-way sync can ensure that both teams are working with the same data. This can help avoid errors and miscommunications arising when working with different tools.
Transition to Fibery: When one team starts using Fibery while the rest of the organization uses a third-party tool or service, two-way sync can ensure that data is shared seamlessly between the two systems. This can help to ease the transition to Fibery and minimize disruptions to existing workflows.

Currently, the only two-way import sync is Jira two-way sync

Integration platforms

Integration platforms are like matchmakers for apps and tools. They help them connect and work together seamlessly. You can use them to create custom workflows that automate tasks and synchronize data between different tools.

We support the two most popular platforms:

Custom integration

In addition to the supported integration platforms, Fibery also allows to Create Custom Integrations, enabling tailored solutions for specific needs or industries.

To use the Import and Integration features, you must have at least Creator rights on the Space level and Admin rights on the Workspace level.

Request Import and/or Integration

If you cannot find an import or integration you need, please provide us with feedback through this form.

Prevent integration entity deletion if it has any custom schema

Integration sync can cleanup entities like Source for Highlights, and it is quite dangerous, since restoration is not super easy. From now on, integration entities with ANY schema modifications will not be deleted during sync. This applies if:

At least one custom field has been added by an admin.
The entity has any rich text field.

To manage source-deleted entities, we’re introducing a Simple Text field deleted in source with values yes and no. If an entity with a modified schema is deleted in the source, the value will be set to yes. Admins can then manually delete these entities if needed. This feature ensures a safer environment for your custom data.

FAQ

Integrations preserving references, backlinks and links

We recommend checking this community thread for more details, since there is no direct import supported.

Can I preserve internal links when importing content into Fibery (e.g. from Obsidian, Roam research, or Quip)?

Yes - with some preparation and scripting, it’s possible to map internal links from your imported files into actual Fibery references, so they function like native entity mentions and power features like backlinks and References.

What kinds of links can be mapped to Fibery references?

This process can work for content exported from tools like:

Obsidian – uses [[Page Title]] format (wiki-style links)
Quip – similar markdown links, also usually [Link Text](URL)

The key requirement is:

The link text should match the title (name) of the page or entity that will exist in Fibery.
How to convert the links into Fibery references?
You can import your content (e.g. as .md or via .csv) into a Docs database in Fibery. Then, using an automation script, you can:

Parse the text in each entity for specific link patterns (e.g. [[Page Title]]).
Look up the matching entity by name in Fibery.
Replace the raw link with an internal mention like [[#^DatabaseID/EntityID]] so Fibery treats it as a reference.

A full working script example:

const fibery = context.getService('fibery');

//get the whole schema
const schema = await fibery.getSchema();
//get the entity type
const typeName = args.currentEntities[0].type;
// filter the schema for the specific type and get the spacename and database id
const namespace = schema['typeObjects'].filter((obj) => obj.name == typeName)[0]['nameParts']['namespace'];
const databaseID = schema['typeObjects'].filter((obj) => obj.name == typeName)[0]['id']
//get all documents in the database (assumes DB is called Doc)
const allDocs = await fibery.graphql(namespace, "{ findDocs{ id, name }}");

//create a lookup table that matches entity names to 'mentions'
//the mentions are constructed from the database id and the entity id 
const lookupTable = allDocs['data']['findDocs'].reduce((obj, item) => (obj[item.name] = "[[#^" + databaseID + "/" + item.id + "]]", obj), {});

//for each entity
for (const entity of args.currentEntities) {
    //get the contents of the Description field (change to suit)
    const textToUpdate = await fibery.getDocumentContent(entity['Description']['Secret']);
    //check for not null doc
    if (textToUpdate !== null) {
        //look for substrings that match the Obsidian formatting (as exported from Fibery)
        //Note: Fibery escapes the [ and ] characters with backspaces, so we are looking for
        //  \[\[Title of obsidian document\]\]
        //and the regex needs to escape these characters!
        const replacementText = textToUpdate.replace(/\\\[\\\[[^\\\]]+\\\]\\\]/g, (match, key) => {
            //trim to get the title to be looked up (remove the \[\[ and \]\] bits )
            const title = match.replace(/\\\[\\\[|\\\]\\\]/g, '');
            //if a match exists in the lookupTable, then replace
            return lookupTable[title] !== undefined
                ? lookupTable[title]
                : match;
        });
        //write the resultant text back to the Description field
        await fibery.setDocumentContent(entity['Description']['Secret'], replacementText)
    }
};

“Unable to find account” Error

Why am I seeing the “Unable to find account” error?

This happens when the Integration is installed, but the connected integration account has been deleted. Fibery keeps the integration module, but the actual email account is missing — so it can’t sync anything.

How did this happen?

Typical reasons:

You added a personal integration account, it failed, and you deleted it.
The integration stayed in place, but now it has no account linked.
Fibery tries to sync → can’t find the account → shows the error.

How do I fix it?

Just reconnect an account — you don’t need to reinstall the whole integration.

Open the … menu on the Email integration.
Click Configure.
Select an existing account or add a new one.

Once an account is linked again, everything will work normally.

Do I need to reinstall the entire integration?

No. You only need to attach a new integration account, not reinstall the integration itself.