# The Pandium Platform Pandium helps SaaS companies deliver scalable native integrations while offloading authentication, hosting, and logging. Pandium’s Integration Platform allows SaaS businesses to offer scalable, high-volume native integrations to their customers while Pandium manages the technical elements like authentication, hosting, and logging. ### Streamlined Development Process The platform’s [Integration Hub](https://www.pandium.com/integration-hub) not only manages the foundational infrastructure and repetitive processes necessary for building, maintaining, and supporting user-facing integrations, but also alleviates the burden on developers by eliminating the need to handle authentication every time an integration is deployed to a customer. Plus, once an integration to a particular system is set up in Pandium, there's no need to start from scratch for every new user or customer who wants that integration. This makes deploying to new users and updating integrations faster. ### Automated Building and Versioning Pandium’s Integration Hub and [pre-built authentication connectors](https://docs.pandium.com/quick-start/key-terminology#connector) enable developers to create highly configurable and reusable integrations using the tools already in their tech stack. The platform is compatible with all major repositories, including GitHub, Gitlab, Azure DevOps, and Bitbucket.
After an integration is created in Pandium, different instances of that integration can be deployed to different customers via the Pandium UI.
# What Companies Use Pandium For Pandium’s platform provides SaaS companies with scalable, high-volume integrations without the infrastructure overhead. * Launch highly configurable, reusable, and dynamic native integrations. * Automate release management. [Release management](https://docs.pandium.com/quick-start/key-terminology#release) options and versioning within the platform make it easy to update your integrations and track changes. * Set customer-specific deployment without having to build the infrastructure to enable and manage this. * Give customers the ability to build custom user experiences with the [Pandium API](https://docs.pandium.com/reference/pandium-api). * Deploy integrations to specific customers or empower clients to discover and install integrations via an embedded In-App Marketplace UI in your app. * Showcase your ecosystem of integrations and partners to customers, partners, and prospects via our In-App Marketplace and Public Gallery products. * Give customers more visibility into their integrations and enable them to install apps, manage configurations, define sync schedules, and view logs via a customizable marketplace experience. * Manage relationships with technology partners. Invite partners to submit integrations, marketing materials, and documentation for their tile within your marketplace. # Platform Structure Understand the technical architecture of the Pandium platform. Pandium takes care of the infrastructure required for customer-facing integrations. ### Platform Structure  The Pandium platform equips businesses with the required infrastructure to efficiently launch native integrations. Pandium includes prebuilt authentication via our [Connectors ](https://docs.pandium.com/getting-started/key-terminology#connector)and secrets management to facilitate system-to-system authentication. Pandium supports both public and private APIs and allows full utilization of the target system's API for integration development. SFTP or even direct database connections can also be used to build integrations using Pandium, if granted the necessary access. Developers create custom business logic (ETL) to craft integration configurations and sync options that align with specific requirements. Connecting their repository to Pandium automates building, [release](https://docs.pandium.com/quick-start/key-terminology#release), and versioning processes. Within Pandium's UI, sync and configuration options are surfaced and accessible, and authentication is handled through pre-built connectors. Our platform allows users to select specific flows or integration versions for deployment, streamlining integration CI/CD management via a [source control](https://docs.pandium.com/build/source-control) process that connects repositories to the platform. This approach facilitates the reuse of connectors, versions, and configurations. Speeding up deployment of future integrations for different customers or [tenants](https://docs.pandium.com/getting-started/key-terminology#tenant). Pandium also lets users modify or update integration configurations as needed through the App/Script in the repository. ### The Pandium YAML The PANDIUM.yaml takes the business logic that specifies the sync and configuration options and surfaces them on the Pandium UI where they can be used to deploy customer-specific integrations. Optionally, these sync & configurations options can be shown to customers via the Pandium In-App Marketplace. Learn more about the Pandium.yaml [here](https://docs.pandium.com/build/anatomy-of-an-integration/pandium.yaml-spec). # Users of Pandium Understand the different types of users that can exist in the Pandium Integration Platform, including platform, engineering, partner and end-customer users. ## Platform User A Pandium platform user is an employee of a B2B software company that has access to the Integration Hub part of the platform. This user may be a customer success rep, partnership manager, product manager and/or marketer. Platform users troubleshoot, configure, and onboard end-customers to new integrations. A platform user may also run reports, monitor behavior, or set up marketplaces or marketing content. ## Engineering User A Pandium engineering user is the software developer who is building integrations that run on the platform. An engineering user may be an employee of your customer, a partner's engineer, a third-party developer like a development agency, or a member of Pandium's professional service team. Engineering users typically provision new integrations and then perform development locally. From there, an engineering user's interaction with the platform is typically related to version management, testing, and troubleshooting. ## Partner User A partner user is a third-party user that is submitting integrations to our customer. Often a partner user is another SaaS company that wishes to be listed in your Pandium-powered marketplace; however, a partner user could also be a development or marketing agency. Partner users can submit marketing content and/or apps for approval and publication in your first-party marketplace, and can also see tenants and runs associated with integrations they own. Partners are invited by Pandium users and access can be revoked at any time. ## Customer End User An end-customer user is the business user that is the customer of Pandium's customer. End-customers are often referred to as tenants, and they are the ultimate consumers of apps running on Pandium. End-users typically do not know that Pandium exists but interact with the platform through a white-labeled UI that is hosted by Pandium, living inside your application. End-customers authenticate into connected systems and manage their own configuration options as specified by the engineering user of the platform. # Anatomy of an Integration A more technical look into the structure of Pandium and a deeper dive into the workings of how integrations are hosted and run on our platform.  On Pandium, integrations are constructed as a simple Posix compliant [command line interface](https://en.wikipedia.org/wiki/Command-line_interface) application (CLI). The CLI should read tenant configuration and connector secrets from [environment variables](/getting-started/anatomy-of-an-integration/environment-variables). Any logs you wish to display to your end users should be written to [`stderr`](/getting-started/anatomy-of-an-integration/environment-variables/stderr). One can pass information to the next run by writing a json encoded string to [`stdout`](/getting-started/anatomy-of-an-integration/environment-variables/stdout). On the next run it will be injected in as an environment variable named`PAN_CTX_LAST_RUN_STDOUT` or `PAN_CTX_LAST_SUCESSFUL_RUN_STDOUT.` # Run Triggers Control how Pandium integrations sync data with cron, manual, webhook, and API run triggers, including payload handling and debouncing per tenant. ### What Are Run Triggers? End users can initiate syncs on a Pandium tenant in multiple ways: via a regular schedule, by clicking a button in the In-App Marketplace, or by sending a webhook. Pandium customers can also design their own mechanisms to trigger syncs by using the Pandium API. Integration scripts can be written to handle one or more of these methods; it is possible for a single integration script to handle more than one trigger type. The code can even be customized to respond differently depending on the run trigger method. Additionally, API and webhook triggers can contain information in the payload body that Pandium makes available to the integration code. If planning for an integration to only ever run via scheduled job or be triggered manually, run triggers can safely be ignored. #### Run Triggers In Depth Pandium represents the four ways that users can trigger runs via four different modes: API, Webhook, Cron, and Manual. Crons are scheduled syncs. Manual syncs are triggered after clicking a button within either the Integration Hub or In-App Marketplace. API and webhooks triggers are self-explanatory. Pandium debounces triggers in order to prevent more than one sync happening per tenant at any given time. If a sync request comes in while the integration script is running for a tenant, Pandium will bundle the triggers and pass them into a new run that will start when the current run is completed. Crons are scheduled in their own, discrete queue and given priority over other types of runs. This ensures scheduled syncs do not fall behind. Crons are only ever bundled with other cron jobs, but the other three trigger types can coexist on a single run trigger array. On the other hand, if the integration is going to be receiving payloads when it is triggered by a webhook or API call, understanding run triggers and how to access them in your code is key. ### Run Triggers in Integration Code Within a run's [context](https://docs.pandium.com/getting-started/anatomy-of-an-integration/environment-variables/stdout#dynamic-sync-variables), the run triggers array is stored in the [environment variable](https://docs.pandium.com/getting-started/anatomy-of-an-integration/environment-variables) PAN\_CTX\_RUN\_TRIGGERS. A trigger is a JSON object that contains information about how the run started, including run mode (init or normal), trigger source, and payload data as well as any headers it was sent with. If you're writing an integration that is receiving webhooks or API requests with payloads, the payload data is stored in a file that can be accessed using your language's built-in file reading functionality. As an example, below is a script in Javascript that gets the run triggers/payloads from the Pandium context inside an integration: ```javascript const runTriggers = JSON.parse(process.env.PAN_CTX_RUN_TRIGGERS) const payloads = [] for (const trigger of runTriggers) { // Only webhooks and API triggers have payloads if trigger.mode === 'webhook') { const data = fs.readFileSync(trigger.payload.file, 'utf-8') // do something with data from payload } } ``` ### Run Trigger Examples The run triggers exposed to your integration via environment variables will have one of the following modes: cron, manual, webhook, or api. Below is an example of a webhook trigger: ```json { "id": "4731234254284123", "source": "webhook", "payload": { "file": "sample/test_file.txt", "headers": { "User-Agent": "PostmanRuntime/7.29.0" } }, "created_date": "2023-01-27T23:27:07Z", "mode": "webhook" } ``` {% hint style="info" %} Should your application require a webhook secret key for verification purposes, you can obtain this within your Pandium Admin Dashboard via the Connector Info on your [Tenant Details Page](https://docs.pandium.com/integration-hub/managing-and-updating-tenants-in-the-admin-portal). {% endhint %} Below is an example of an API trigger: ```json { "id": "12345678", "source": "api", "payload": { "file": "sample/test_file.txt", "headers": { "User-Agent": "PostmanRuntime/7.29.0" } }, "created_date": "2023-06-06T10:11:50-04:00", "mode": "normal" } ``` Below is an example of a manual trigger: ```json { "id": "12345678", "source": "manual", "created_date": "2023-06-06T10:11:50-04:00", "mode": "init" } ``` Below is an example using cron: ```json { "id": "example_id", "source": "cron", "created_date": "2023-06-06T10:11:50-04:00", "mode": "normal" } ``` ### # Run Failures Learn about Pandium run failures, their causes (integration, refresh, platform, timeout), and how to troubleshoot or report issues effectively. ### What Are Run Failures? In the instance that an error occurs during a sync, there are four possible status that will be reflected for a run: * Failed (Integration Issue) * Failed (Refresh) * Failed (Platform Issue) * Failed (Timeout) #### Integration Issues If something fails inside your integration code, in order to properly reflect a failed status, it is the responsibility of the integration development team to exit the process with a failed status code. Below are some examples codes that can be used for different languages:
| Language | Set & Continue | Immediate Exit |
|---|---|---|
| Node.js | process.exitCode = 1 | process.exit(1) |
| Java | ❌ | System.exit(1) |
| C# | Environment.ExitCode = 1 | Environment.Exit(1) |
| PHP | ❌ | exit(1) or die(1) |
# PANDIUM.yaml Learn how to structure and configure your PANDIUM.yaml file to build, run, and customize integrations on the Pandium platform using schema and UI settings. The PANDIUM.yaml provides information to build and execute an integration script on the Pandium platform. It also defines the configuration options and UI, via the configs section, where tenant end users will input information vital to the integration run. ## Name and Location When [setting](/integration-hub/setting-up-your-first-integration-tile) up an internal integration on the Integration Hub, it will ask for a Repository Path. Specify the name and location of the file with respect to the root of your integration code repository. If not set, by default, Pandium will look for a file named PANDIUM.yaml in the root directory.
Repository Settings
PANDIUM.yaml in the Connections Settings Page
when null or undefined control renders as a text box. date renders as a date picker
time renders as a time picker and date-time renders a date and time control.
| | **enum** | an array of values | if you add an enum to the control, it will render as a dropdown. |  ### Enum ```yaml string_enum_input: enum: - option 1 - option 2 - option 3 type: string ``` In the above example, string\_enum\_input is the name of the config. When presented to the Integration Hub user, they will see a select box allowing them to choose between the given enum values. When a Run happens this config will be injected into the Environment as PAN\_CFG\_STRING\_ENUM\_INPUT.  ### Labeled Enum ```yaml labeled_enum: type: string oneOf: - title: Option 1 label const: option1 - title: Option 2 label const: option2 - title: Option 2 label const: option2 ``` In the above example, labeled\_enum is the name of the config. When presented to the Integration Hub user, they will see a select box with labeled values. When a Run happens this config will be injected into the Environment as PAN\_CFG\_LABELED\_ENUM.How the Integration Hub user will see this when combined with UISchema
How the Integration Hub user will see this when combined with UISchema
Required.
Determines which schema property this UISchema element displays.
Has the following format ‘#/properties/\[property\_name]’
Not Required.
Used to customize the text seen for the control on the connections settings page.
Not Required.
When true, the element will only render for Integration Hub users.
Not required. For full-width inputs, useoptions:trim: false
Required for Control.
Determines which schema property this uischema element displays.
Has the following format ‘#/properties/\[property\_name]’
The schema property referenced in its scope must be formatted as a multi select enum.
MultiSelectControl UISchema Element
Label UISchema element
Elements displayed in a Section UISchema Element
The only food type option for Tenant A are "Sweet" and "Savory"
When the user selects the "Sweet: food type, the options for favorite food are only sweet foods.
When the user selects the "Savory" food type, the options for favorite food are only savory foods.
The only food type option for Tenant B are "Fruits" and "Veggies"
When the user selects the "Fruits" food type, the options for favorite food are only fruits.
When the user selects the "Veggies" food type, the options for favorite food are only vegetables.
configs:
schema:
definitions:
food_type_options:
oneOf:
- const: Placeholder
title: Placeholder
food_options:
type: object
properties:
food_type:
$ref: "#/definitions/food_type_options"
favorite_food:
type: string
optionsMapPath: '#/definitions/food_options'
parentField: '#/properties/food_type'
uischema:
type: VerticalLayout
elements:
# Parent
- label: Food Type
scope: '#/properties/food_type'
type: Control
# Dependent
- label: Favorite Food
scope: '#/properties/favorite_food'
type: Control
* `schema` is a standard json schema. For more information, please see here -
* GET -
1. Pull up the tenant in question 2. Navigate to Details > Select Show next to Tenant Metadata\
Example of NetSuite Secret Formats within the Integration Hub
| name | description | notes |
|---|---|---|
| PAN_CTX_INTEGRATION_ID | The Pandium ID of the Integration that is running currently. | an integer unique to your account |
| PAN_CTX_INTEGRATION_NAME | The name of the Integration that is running currently | |
| PAN_CTX_TENANT_ID | The Pandium ID of the Tenant that is running currently. | An integer unique to your account |
| PAN_CTX_TENANT_NAME | The name of the Tenant that is running currently. | |
| PAN_CTX_RUN_MODE | An enum of one of the following values: init , normal, webhook | |
| PAN_CTX_RUN_TRIGGERS | List of objects that contain the payload data for run triggers | Can view the mode, source, and payload data as well as headers it was sent with |
| PAN_CTX_ENV | The environment the sync is running in, i.e. dev/staging/prod | |
| PAN_CTX_LAST_RUN_START_TIME | A datetime that represents the time the last run started. i.e. 2021-07-24 20:04:21 +0000 UTC | Will appear in environment only after first run. |
| PAN_CTX_LAST_RUN_COMPLETION_TIME | A datetime that represents the time the last run completed. i.e. 2021-07-24 20:07:21 +0000 UTC | Will appear in environment only after first run. |
| PAN_CTX_LAST_RUN_PHASE | An enum of one of the following values: Succeeded, Failed (Platform Issue), Failed (Integration Issue) , Failed (Timeout) | Will appear in environment only after first run. |
| PAN_CTX_LAST_RUN_STD_OUT | The JSON encoded string that was optionally printed to stdout during last Run. | |
| PAN_CTX_LAST_SUCCESSFUL_RUN_START_TIME | A datetime that represents the time the last successful run. i.e. 2021-07-24 20:04:21 +0000 UTC | Will appear in environment only after successful first run. |
| PAN_CTX_LAST_SUCCESSFUL_RUN_COMPLETION_TIME | A datetime that represents the time the last successful run completed. i.e. 2021-07-24 20:07:21 +0000 UTC | Will appear in environment only after successful first run |
| PAN_CTX_LAST_SUCCESSFUL_RUN_PHASE | An enum of one of the following values: Succeeded, Failed (Platform Issue), Failed (Integration Issue) , Failed (Timeout) | Will appear in environment only after successful first run |
| PAN_CTX_LAST_SUCCESSFUL_RUN_STD_OUT | The JSON encoded string that was optionally printed to stdout during last successful Run. |
In this example the remote repository is at https://github.com/pandium/sample_integrations.git. In step 1 the pokemon-integration branch was added to that repository. The repository path tells Pandium to create a folder called POKEMON_OF_THE_DAY within that repository, and to add the starter files to that folder.
├── src
└── index.ts
└── lib.ts
└── package.json
└── PANDIUM.yaml
└── tsconfig.json
# Pandium Clients Get out-of-the-box Pandium API clients that handle pagination, retries, rate limiting, and IDE hints so you can quickly build B2B SaaS integrations without custom plumbing. Pandium's Clients, fill a gap in the market by offering B2B SaaS organizations out-of-the-box plumbing for **connecting directly with APIs** to build and launch integrations. ## Why Use the Pandium Clients? 1. Pandium has [hundreds of pre-built connectors](/connectors/connectors-101) to choose from. 2. Our API clients seamlessly interacts with APIs. They take care of paging, automatic retries, and rate limiting - all ensuring optimized throughput. 3. Our API clients also provide context-aware code insights on the APIs being integrated. This **eliminates the need to constantly reference API docs** while coding an integration’s business logic. ## How to Access the Pandium Clients 1. Pull your code from your remote repository down onto your local machine to start working in your IDE with the client in the integration. 2. You will see an example of how to instantiate the client. If you included code generation, you will see the client passed to a flow. Within the flow, the client instance will have been used to either fetch or post something to the API.\ \ If you did not include code generation, you will see the client used to fetch some records. ## How to Use a Pandium Client 1. Once a client has been added to your project, import your client to any file in the project using {% code title="Import Format" %} ```markup import [Client Name] from '@pandium/[connector]-client' ``` {% endcode %} {% code title="Importing ShipBob Client" %} ``` import ShipbobClient from '@pandium/shipbob-client' ``` {% endcode %} How to import additional models
import { CreateTicketModel } from '@pandium/shipbob-client'
The Source Control page in Admin Settings
The key can be whatever you want in order to access the secret value during a build.
# Getting Started with Creating an Integration Learn how create a record of your integration in Pandium, as well as configure your integration details, connectors, remote repository settings, and sync schedule options. ### Choosing Your Integration Type Pandium supports two types of integrations: internal and external. Internal integrations involve code execution, authentication, and run management on the Pandium platform. Most developers will be creating internal integrations. On the other hand, external integrations are primarily used for pre-existing integrations, 3rd party collaborations, or marketing purposes. Marketers or partners often create these integrations. ### Creating An Internal Integration 1. Navigate to the ‘Integrations’ resource and click ‘Create.’ 2. In the pop-up widget, select ‘Internal.’ 3. Configure your connectors: * Most integrations will need a minimum of two connectors: your SaaS and the SaaS you are integrating with. There may be instances with more than two connectors, but they are uncommon. * Each connector has a ‘global’ checkbox option, typically not needed. Use this when all end users will share the same authentication credentials, as in the case of an SFTP. 4. Configure your details: * Integration ID: A backend unique identifier for the integration. For example, if t integrating with Gorgias, it may be called “gorgias”. * Integration Name: The public name for the Integration. End users will use this name to gauge what type of integration it is. Using the Gorgias example, the name may be “Gorgias Helpdesk.” 5. Configure your Remote Repository Settings: * Repository URL: The URL where the integration code is hosted. * Repository Tracking Branch: The branch Pandium should use to create the integration. * Repository Path: The path where Pandium can find the Pandium.yaml. Leave it blank if the .YAML is in the root and is named ‘PANDIUM.yaml.’ 6. Set your Sync Schedule options: * Customize the sync schedule options you would like to offer to your end user for this integration. You may leave the default options if you choose. 7. 'Save the Configuration 8. Provision Connectors: * Depending on the selected connectors, one or more of your connectors may need provisioning especially for SaaS using OAuth. Enter client id, client secret, and potentially select scopes. * Grab Secret Keys for development purposes, specific to the SaaS. You can read more about Environment Variable Secrets, [here](https://docs.pandium.com/getting-started/anatomy-of-an-integration/environment-variables). 9. You're Done! ### Creating An External Integration 1\. Navigate to the ‘Integrations’ resource and click ‘Create.’ 2\. In the pop-up widget, select ‘External.’ 3\. Provide relevant details for the integration. * Integration ID: This serves as a backend unique identifier for the integration. For example, a Gorgias integration might be named “gorgias”. * Integration Name: This is the public name for the Integration, Used by end users to identify the type of integration. Using the Gorgias example, the name might be “Gorgias Helpdesk”. 4\. Fill in the associated External Integration Settings: * External Integration Url: This is the path to install or learn more about the integration. It could be a link to the 3rd party’s Integration Marketplace if hosted externally, or a deep link to the installation URL for pre-existing integrations on your SaaS platform. If used to gather Beta end users, it might link to a Google form or info page. * External Integration ID: This ID is sent to Pandium by your engineering team in the marketplace JWT. This field is primarily used for pre-existing integrations, ensuring Pandium accurately shows whether the integration is installed for an end user. * External Integration Link Target: Choose how the link opens in an end-user’s browser (new tab, same page, etc). 5\. Upon saving, you’ll be prompted to fill in Marketplace Settings for this integration. You can read more about these settings here (link to Marketplace Settings). ### Connecting to Source Control Now that the integration has been created within Pandium, confirm that Source Control is set up by navigating to the ‘Settings’ in the sidebar, then “Source Control” to connect to your repository and set up the CI/CD pipeline. For more detailed information on Source Control and how to set it up, view [this article](https://docs.pandium.com/integration-hub/setting-up-source-control). After connecting to Source Control, if code has been written, create a release from the “Settings” page. If not, go back to ‘Integrations”, click ‘Details’ on your new integration tile, and use the ‘Setup Integration Repo’ button to populate a quickstart for your code in your chosen language. Learn more about building releases for created integrations [here](https://docs.pandium.com/integration-hub/updating-an-integrations-release). # Demo Video: Creating an Integration With Pandium Watch an example of what the full end-to-end integration building processes looks like with Pandium. This demo below walks through setting up an example integration between Apollo.io and HubSpot using Pandium. While the integration example may differ from your specific use case, this video is meant to provide a real-world look at the development process and the key features Pandium offers to streamline integration management. {% embed url="
Default Release Options
Example Provisioning Screen on an Integration
Tenant Creation Flow
Sync Schedules
Example of the tenant detail and connection status
Example of the info button on a connector
Example of sync schedule settings
# Managing External Integrations Manage external integrations in Pandium by configuring marketing-only tiles, target URLs, and marketplace theming to showcase third-party or existing apps without running code on Pandium. ### What are External Integrations? External Integrations in Pandium differ from [Internal Integrations](https://docs.pandium.com/integration-hub/setting-up-your-first-integration-tile) because they’re designed for creating integrations for pre-existing and third-party integrations. This is most relevant when embedding a marketplace and wanting marketing-focused tiles without any installation capabilities, wanting Pandium to show what pre-existing non-Pandium integrations are installed, or highlighting 3rd-party integrations. External integrations are also useful to allow your partners to create app tiles that don’t require advanced configuration setup. This is also particularly useful for the [Public Gallery](https://docs.pandium.com/marketplaces/public-gallery), where tiles can be made purely with marketing content if desired. ### Managing External Integration After [creating](https://docs.pandium.com/integration-hub/creating-an-integration) an external integration, you will land on the main integration detail page where you can view and manage the integration. External integrations are simple to update. Clicking ‘Configure’ on the top right of the integration detail page will bring you to the external integration edit page, where you are able to change the target URL, name, and how the app appears when clicked.
External Integration Edit Page
Klaviyo List selector with a placeholder before init sync is run
Klaviyo List selector with dynamic options after the init sync
Tenant Init Sync Option on Integration Hub
# Managing Users Manage Pandium Integration Hub users by granting full admin access, inviting new team members, and relying on JWT-based identification for end users in embedded marketplaces. ### How to Manage Integration Hub Users Currently, there is only one level of users in Pandium’s Integration Hub, with the exception of partners. All users added to Pandium will be able to create and edit integrations, create and delete tenants, and change marketplace settings. To add new users and view, delete, or reset passwords for any other users, navigate to 'Settings' in the navigation sidebar of the Integration Hub and then “Users.” The only user who can not be deleted is the user designated as the primary administrator for your organization. When adding a new user, the new user will receive an email from Pandium, prompting them to create a new password. ### In-App Marketplace Users Users using the In-App Marketplace do not need to be manually created. Rather, when the marketplace is created and embedded within a SaaS tool, a JSON Web Token (JWT) is created and configured as part of the embedding. This JWT will contain a unique identifier, specific to the SaaS, that will tell Pandium what integration end-user is utilizing the marketplace. This is how Pandium knows what integrations to show as installed and what integrations to list as available. Directions for configuring the JWT for specific groups or classes of users can be found [here](https://docs.pandium.com/marketplaces/customizing-the-jwt).
# Administrator Settings Configure Pandium administrator settings by managing company details, users, notifications, partner and integration forms, source control, and API keys from a centralized Settings area. In the Integration Hub, click on the ‘Settings’ link in the sidebar to access the following tabs: *Note: Partner users will only see the Company, Users, and Source Control tabs. Pandium Lite accounts won't see tabs related to partners (e.g., Integration Form and Partner Form tabs).* Below is an explanation of what each tab in this area entails. ### Company Under the Company tab, you can set the primary administrator for your account, and you also have the option to set logos that will display to your partners in their Integration Hub experience. If using marketplace features, you can also set the base URL, which is the URL of the iframe where you've installed the In-App Marketplace.
 Each of these events can be clicked to get further information on them: * View - Shows when a user views an integration * Delete - Shows when a tenant has been uninstalled * Sync - Shows when a user runs a sync * Connect - Shows when a user clicks connect * Disconnect - Shows when a user disconnects the connector * Schedule - Shows when a scheduling change occurred * Configure - Shows when a configuration change occurred * Install - Shows when an integration has been successfully installed  ### Metrics With An External Marketplace If you exclusively utilize the Pandium marketplace to show integrations that are not hosted on Pandium, i.e. legacy integrations or external integrations, you can still track several events related to your integration tiles in this page, although information gathered will be more limited than integrations hosted on Pandium’s infrastructure. # Bulk Actions Learn about upcoming Pandium Bulk Actions features for efficiently managing admin tasks across multiple integrations, tenants, or runs from a single place. As a Pandium admin user, there may be times when you need to update releases or pause a few tenants during integration maitenance. Rather than perform these tasks one-by-one, there are a few resources you can use to update items in bulk. ### Tenants Whether you are reviewing your list of tenants from the tenants page or within a specific integration, you should see the following three options available to you if you select multiple tenants at once.
From the Tenant Page
From the Tenant Tab via an Integration
1. Pull up the tenant in question 1. You can do this by pulling up the integration or by going to Manage > Tenants 2. Navigate to the run details page for the job you wish to rerun 1. You can also locate the desired run by navigating to Manage > Runs and filter out your search results using the enhanced sorting and filtering resources. 3. Once you have pulled up the run details page, look for the **RERUN** option in the top right of your screen and select it.
The great thing about this option is that you do not have to directly change your tenant settings.
# Sorting, Filtering, & Log Searches Quickly find integrations, tenants, runs, partners, and users in Pandium using rich sorting, filtering, and Boolean log search tools across the Integration Hub and In-App Marketplace. As a Pandium user, there may be instances where you need to quickly parse out specific integration-related details without having to manually sift page by page. You may be managing a large number of tenant runs and need to find ones with a specific status, or maybe you're looking for tenants that use a particular release version to troubleshoot an issue. This could be because you're onboarding a new team member who needs to understand your current setup, or maybe you're auditing, or simply performing integrations maintenance.
In other circumstances, you might need to quickly find specific data that has been processed within one of your integrations, or even better, empower your end users to find this data themselves.\ \ Whatever the case may be, you can utilize sorting and filtering capabilities to help navigate and organize your integration tech stacks more effectively, as well as use log searches to identify discrete data. ## **Pages That Utilize Sorting and Filtering** 1. Integrations 1. Integration Details 1. Runs 2. Tenants 3. Releases 2. Tenants 1. Tenant Details 3. Runs 4. Partners 5. Users ### Integrations When viewing your list of integrations, you can filter out your integrations by type ([External](/integration-hub/managing-external-integrations) vs [Internal](/integration-hub/setting-up-your-first-integration-tile)) and also if the integration was developed by a Partner. For more information regarding working with Partners, please see [here](https://docs.pandium.com/partners/inviting-partners).
1. From the main partner page, you should see the option to search by Partner Organization Name and Partner Status (Approved vs Pending)
# Embedding the In-App Marketplace Embed Pandium’s In-App Marketplace via iframe and JWT-based SSO to securely show user-specific integrations, installations, and configs inside your app without an extra login. ### How Does the In-App Marketplace Work? The Pandium In-App Marketplace product offering is designed to be displayed in an iframe within a web app that sits behind your company's login. In order to maintain the security of your user's data, we suggest that you stand up a backend service that redirects to the Pandium In-App Marketplace with your user's information encoded in a JSON Web Token (JWT). This single sign-on (SSO) mechanism that allows your site to pass information about your users to Pandium and tells Pandium that the user has been authenticated. Pandium uses that information to securely display your users’ specific integration configurations without an extra login. *Note: The Marketplace and related features are not included in the Pandium Lite offering.* ### How to Embed the Marketplace #### Prerequisites Before your site can be enabled for SSO via JWT with Pandium, you will need to reach out to the Pandium support and exchange the below: * A shared secret supplied by Pandium. This is used to sign the JWT, and helps Pandium ensure the requests come from you and you alone. * If embedding a Pandium Marketplace in your application, we'll also need the domain of the application that will serve as the iframe's parent. Pandium needs this for [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) purposes. * *Note: If you are using a Sandbox or PoC environment, we will not need the domain.* #### Getting Started Your application will need to direct your users to a url that looks similar to the below: `https://imp.pandium.io/
*HubSpot forms require Portal ID and Form ID from HubSpot
Example: A Grey Wizard Tech (GWT) integration with enabled marketplace publish settings.
End-user perspective: A Grey Wizard Tech customer integrating with Google Sheets via the In-App Marketplace.
Marketplace URL setting within the "Company" tab under "Settings"
* **Production:**
# Airship Set up the Airship connector in Pandium by configuring your API base URL and scopes so tenants can authenticate securely and power personalized mobile engagement. ## **Connector Overview**
# Alasco Set up the Alasco connector in Pandium using your API key and API token so tenants can authenticate securely and sync construction financial data without extra provisioning. ## **Connector Overview**
1. Log in to your [Anthropic Account](https://console.anthropic.com/) 2. Navigate to Manage > API Keys 3. Select **+Create Key** ## **API Resources** For more information on how to utilize the Anthropic API, feel free to reference the following [documentation](https://docs.anthropic.com/en/home). # Apollo.io Set up the Apollo.io connector in Pandium using your scoped or master API key so tenants can authenticate securely and sync prospecting and sales engagement data. ## **Connector Overview**
## **API Resources** For more information on how to utilize the Attentive API, feel free to reference the following [documentation](https://docs.attentive.com/). # AWS Set up the AWS connector in Pandium using your Access Key ID and Secret Access Key so tenants can authenticate securely and sync cloud resources without extra provisioning. ## **Connector Overview**