@scaleflex/asset-picker

Framework-agnostic Asset Picker Web Component for Scaleflex VXP DAM.
Browse, search, filter, and select assets from your DAM — in any frontend stack.

Live Demo | Documentation | Examples | npm | Scaleflex DAM

• Overview
• Features
• Requirements
• Installation
• Quick Start
  • Vanilla JS / Web Component
  • React
• Configuration
  • Authentication
  • Config Options
  • Integrated uploader
  • Content-Security-Policy & thumbnail proxying
  • Default & Forced Filters
  • Restricting the filter menu
• Public Methods
• Events
• React API
  • Provider + Hook
• Asset Utilities
• Theming
  • Brand Color
  • CSS Custom Properties
• Filters Reference
  • Filter Keys
  • Filter Data Structures
• Types Reference
  • Asset
  • Folder
• Browser Support
• Claude Code Integration
• License

@scaleflex/asset-picker is a drop-in modal component that connects to a Scaleflex VXP DAM project and lets users browse, search, filter, preview, and select digital assets. It ships as a standard Web Component (Custom Element) built with Lit 3, so it works everywhere — vanilla JS, React, Vue, Angular, Svelte, or any other framework.

The npm package contains only pre-built, minified production files (dist/). Source code is maintained in Scaleflex's scaleflex-dam-tools monorepo.

• Framework-agnostic — standard <sfx-asset-picker> custom element, works in any stack
• First-class React wrapper — forwardRef component with controlled open prop and imperative ref
• Two auth modes — security templates or direct SASS key
• Grid & list views — switchable with persistent user preference
• Full-text search — real-time search across your DAM
• 14+ filter types — type, date, size, tags, labels, color, approval status, metadata, and more
• Filter pinning — users can pin favourite filters; persisted to localStorage
• Default & forced filters — pre-apply filters on open or lock filters the user cannot remove
• Infinite scroll — automatic pagination as the user scrolls
• Folder navigation — browse the full DAM folder tree with breadcrumb
• Labels view — browse assets organized by label with breadcrumb navigation
• Asset preview panel — side panel with metadata, thumbnails, and video/audio playback
• Multi-select & select all — single or bulk selection with configurable max
• Keyboard navigation — arrow keys, Enter, Escape, Shift+click range select
• Marquee selection — click-and-drag to select multiple assets
• Approval workflow — filter by approval status, approver, requester, due date
• Regional variants — metadata variant groups with per-variant filtering
• Internationalisation — built-in i18n via i18next; pass locale in config ('fr', 'de', 'en-US', etc.) — falls back to English for untranslated keys
• Customisable theming — brand color config + 20 CSS custom properties
• Tiny footprint — ~70 KB gzipped (main chunk)

• A Scaleflex VXP DAM account with a project token
• Either a security template key or a SASS key for authentication
• Modern browser with Custom Elements v1 support (see Browser Support)

npm install @scaleflex/asset-picker

yarn add @scaleflex/asset-picker

pnpm add @scaleflex/asset-picker

lit is bundled with the package. For React usage, you also need react and react-dom (v18+) as peer dependencies.

No bundler? Add a single script tag:

<script src="https://cdn.scaleflex.com/asset-picker/1.2.3/asset-picker.min.js"></script>

This auto-registers <sfx-asset-picker> — no imports needed. See the CDN quick start below.

Both ESM (import) and CJS (require) builds are provided.

<sfx-asset-picker></sfx-asset-picker>

<script type="module">
  // 1. Register the custom element (once)
  import '@scaleflex/asset-picker/define';

  // 2. Grab the element
  const picker = document.querySelector('sfx-asset-picker');

  // 3. Configure
  picker.config = {
    auth: {
      mode: 'securityTemplate',
      securityTemplateKey: 'YOUR_KEY',
      projectToken: 'YOUR_TOKEN',
    },
    locale: 'fr', // optional — defaults to 'en'
  };

  // 4. Listen for events
  picker.addEventListener('ap-select', (e) => {
    console.log('Selected assets:', e.detail.assets);
  });

  picker.addEventListener('ap-cancel', (e) => {
    console.log('Cancelled via:', e.detail.reason);
  });

  // 5. Open
  picker.open();
</script>

import { useRef } from 'react';
import { AssetPicker, type AssetPickerRef } from '@scaleflex/asset-picker/react';

function App() {
  const pickerRef = useRef<AssetPickerRef>(null);

  return (
    <>
      <button onClick={() => pickerRef.current?.open()}>Pick assets</button>

      <AssetPicker
        ref={pickerRef}
        config={{
          auth: {
            mode: 'securityTemplate',
            securityTemplateKey: 'YOUR_KEY',
            projectToken: 'YOUR_TOKEN',
          },
          locale: 'fr', // optional — defaults to 'en'
        }}
        onSelect={(assets) => console.log(assets)}
        onCancel={() => console.log('Cancelled')}
      />
    </>
  );
}

<!DOCTYPE html>
<html>
  <head>
    <script src="https://cdn.scaleflex.com/asset-picker/1.2.3/asset-picker.min.js"></script>
  </head>
  <body>
    <sfx-asset-picker></sfx-asset-picker>
    <button onclick="document.querySelector('sfx-asset-picker').open()">Open Picker</button>

    <script>
      const picker = document.querySelector('sfx-asset-picker');
      picker.config = {
        auth: {
          mode: 'securityTemplate',
          securityTemplateKey: 'YOUR_KEY',
          projectToken: 'YOUR_TOKEN',
        },
        locale: 'fr', // optional — defaults to 'en'
      };
      picker.addEventListener('ap-select', (e) => {
        console.log('Selected:', e.detail.assets);
      });
    </script>
  </body>
</html>

The picker supports two authentication modes:

Use for client-side integrations. The picker automatically exchanges the security template key for a SASS key on init.

{
  auth: {
    mode: 'securityTemplate',
    securityTemplateKey: string,   // Exchanged for a SASS key via API
    projectToken: string,
  }
}

Use when your application already has a SASS key — e.g. inside the Scaleflex Hub where the host app manages SASS key generation and renewal.

{
  auth: {
    mode: 'sassKey',
    sassKey: string,         // X-Filerobot-Key
    projectToken: string,
  }
}

The full, always-current list of AssetPickerConfig properties lives on the live demo docs site, not duplicated here to avoid two copies drifting apart:

→ Config Options reference

Highlights: auth (required), locale, multiSelect / maxSelections, tabs, defaultFilters / forcedFilters, enabledFilters / enabledMetadataFields, variants, transformations, uploader (integrated uploader), brandColor, transformRemoteThumbnail, onSelect / onCancel. The authoritative shape is always src/types/config.types.ts.

Set uploader to add an "Upload" button to the toolbar and turn the content area into a drop zone. Requires @scaleflex/uploader to be installed. Auth and target folder are derived automatically from the picker's own auth and current folder — do not set them:

picker.config = {
  auth: {
    mode: 'securityTemplate',
    projectToken: 'YOUR_CONTAINER',
    securityTemplateKey: 'SECU_...',
  },
  uploader: {
    autoProceed: false,
    showCopyCdnButton: true,
  },
};

Pass uploader.metadataConfig to let users fill project metadata before upload. An empty object is all it takes — including in securityTemplate auth mode:

picker.config = {
  auth: {
    mode: 'securityTemplate',
    projectToken: 'YOUR_CONTAINER',
    securityTemplateKey: 'SECU_...',
  },
  uploader: {
    metadataConfig: {
      enforceRequiredBeforeUpload: 'auto',
    },
  },
};

The "Fill Metadata" button appears automatically once metadataConfig is set. With no hubHeaders, the schema is loaded from the container's /v5/settings endpoint using the SASS key the uploader exchanges from your security template — no session token, no proxy, no pre-fetched schema and no projectUuid: that request is scoped to your container, which already identifies the project. Field groups, select options, regional variants, required-field enforcement and product fields all work on this path.

Add projectUuid only when you want the Hub — it is the id in the Hub's /project/{uuid} URL, and metadata dependency rules are Hub-only. Without it the uploader goes straight to /v5/settings and leaves dependency rules off.

Two things need Hub session auth, which a security template cannot provide:

If your app does have a Hub session, pass the tokens to get both back:

uploader: {
  metadataConfig: {
    projectUuid: 'YOUR_PROJECT_UUID',
    hubHeaders: {
      'x-session-token': sessionUuid,
      'x-company-token': companyUuid,
      'x-project-token': projectUuid,
    },
  },
}

When the session token arrives asynchronously, assign a new config object once it is available — in-place mutation is not detected. metadataConfig.schemaSource ('auto' by default, or 'hub' / 'settings') overrides which source is used.

If the host page enforces a Content-Security-Policy that does not allow the Filerobot asset CDN (assets.filerobot.com / *.filerobot.com) as an img-src, asset thumbnails will be blocked. Use transformRemoteThumbnail to rewrite every preview image URL through a CSP-permitted proxy:

picker.config = {
  auth: {
    /* ... */
  },
  transformRemoteThumbnail: (url, ctx) => {
    // ctx.source: 'asset' | 'video' | 'pdf' | 'folder' (+ 'url-import' | 'connector'
    // when forwarded to the integrated uploader). ctx.asset is the Asset when available.
    return `https://proxy.example.com/?u=${encodeURIComponent(url)}`;
  },
};

What it covers:

• Rewritten: grid cards, list rows, folder previews, and every image in the preview panel — the main image, the fullscreen image, and the video poster. If the uploader is enabled, the same function is forwarded to it (ctx.source is 'url-import' or 'connector'), so branch on ctx.source to handle both.
• Not rewritten: the <video> / <audio> playback streams (including HLS). Those are the actual media, not previews — allow their origin in media-src instead.

Notes:

• Return the original url (or any falsy value) to leave it unchanged. The callback runs once per image per render, so keep it pure and cheap; thrown errors are caught and the original URL is used.
• The transform is registered process-wide. If two pickers share a page the last one configured wins, and a picker mounted without this option clears a previously registered transform.
• File-type fallback icons (shown for non-thumbnailable assets) are served from scaleflex.cloudimg.io and are not routed through this callback. A strict CSP must allowlist that origin in img-src, or use a CDN proxy at the network level for it.

You can pre-configure filters that are applied when the picker opens, and/or lock filters that the user cannot remove.

picker.config = {
  auth: {
    /* ... */
  },

  // Pre-applied on open — user can modify or remove
  defaultFilters: {
    type: { type: 'string', values: ['image'] },
  },

  // Always active — locked chip with lock icon, cannot be removed
  forcedFilters: {
    tags: { type: 'string', values: ['approved'] },
  },
};

// Lock to specific extensions using subtype values (category_extension)
forcedFilters: {
  type: { values: ['image_svg', 'image_png'] },
},

Behaviour:

• defaultFilters are seeded into the applied filters state when open() is called. The user sees them as normal filter chips and can modify or remove them freely.
• forcedFilters are merged into every API request but are not stored in the mutable applied state. They render as locked chips (with a lock icon instead of an X button). The user cannot remove them, and "Clear filters" does not affect them. Forced filter keys are also hidden from the "Add filter" dropdown.
• If the same key appears in both defaultFilters and forcedFilters, the forced filter takes precedence — the default filter for that key is skipped.

enabledFilters limits which filters the Filters menu offers:

picker.config = {
  auth: {
    /* ... */
  },
  enabledFilters: ['type', 'date', 'size'],
};

Behaviour:

• Only the listed keys appear in the Filters menu. Pass [] to hide the Filters button entirely; omit the option for all filters.
• Excluded keys are also hidden from the pinned-filter chips, and dropped from defaultFilters — otherwise the user would get a chip they can remove but not add back. The saved pin list itself is not rewritten: it is keyed by project token and shared across every picker on the origin, so a restricted picker hides pins without erasing them for an unrestricted one.
• forcedFilters are unaffected — a locked filter always applies, since it is never user-removable in the first place.
• Only filters that have a menu entry are governed. mimetype, folders, resolution, orientation, faces and products are integrator-only keys reachable solely through defaultFilters / forcedFilters; they always pass through, whatever enabledFilters lists.
• Approval sub-keys (approval_status, task_approver, task_requester, task_duedate) follow their parent approval entry.

approval is a container, like metadata: its menu entry opens a list of four independent filters rather than a panel of its own. Each one gets its own chip, popover and pin.

Approver and Requester are listed only when the matching user list is configured — see approverUsers / requesterUsers. All four are usable as defaultFilters / forcedFilters keys whether or not the menu offers them.

enabledMetadataFields limits which metadata fields can be added as filters, independently of enabledFilters (which governs the metadata entry as a whole):

picker.config = {
  auth: {
    /* ... */
  },
  enabledMetadataFields: ['campaign_name', 'photographer'],
};

Behaviour:

• Keys are the raw MetadataModelField.key from the project's schema (unprefixed — e.g. 'campaign_name', not 'text_campaign_name').
• Only the listed fields appear in the "Add metadata field" popup, the toolbar's metadata filter, and the metadata filter chips. Pass [] to make no metadata fields available; omit the option for all fields.
• A pinned field excluded here is hidden from the filters bar even if it is still present in localStorage — the saved pin list itself is left intact, same as enabledFilters.
• Keys with no match in the project's metadata schema are ignored silently.
• Does not affect the preview panel, which always shows the full metadata field list — that's governed separately by showMetadata.

The picker ships with English strings baked in as fallbacks. To render the UI in a different language, pass a BCP 47 locale tag via locale. Translations are loaded lazily from the Scaleflex TMS CDN on first use; if a key is not yet translated the English default is shown.

picker.config = {
  auth: {
    /* ... */
  },
  locale: 'fr', // 'fr', 'de', 'en-US', etc. — defaults to 'en'
};

To debug missing translations locally, set the flag in localStorage and reload — untranslated keys are logged to the console:

localStorage.setItem('apTranslationsMissingKeysEnabled', 'true');

// Open the picker
await picker.open();

// Close programmatically
picker.close();

All events bubble and cross shadow DOM boundaries (composed: true).

picker.addEventListener('ap-select', (e) => {
  const { assets } = e.detail;
  assets.forEach((asset) => {
    console.log(asset.name, asset.url?.cdn);
  });
});

picker.addEventListener('ap-cancel', (e) => {
  console.log('Cancelled via:', e.detail.reason);
});

picker.addEventListener('ap-error', (e) => {
  console.error(`[${e.detail.context}]`, e.detail.error);
});

import {
  AssetPicker,
  type AssetPickerRef,
  type AssetPickerProps,
} from '@scaleflex/asset-picker/react';

const [isOpen, setIsOpen] = useState(false);

<AssetPicker
  config={config}
  open={isOpen}
  onSelect={(assets) => {
    console.log(assets);
    setIsOpen(false);
  }}
  onCancel={() => setIsOpen(false)}
/>;

const ref = useRef<AssetPickerRef>(null);

<button onClick={() => ref.current?.open()}>Open</button>
<AssetPicker ref={ref} config={config} onSelect={handleSelect} />

For apps that open the picker from many places, use AssetPickerProvider + useAssetPicker() to avoid managing open/close state yourself. One picker instance is mounted at the root and shared across the tree.

import { AssetPickerProvider } from '@scaleflex/asset-picker/react';

function App() {
  return (
    <AssetPickerProvider
      config={{
        auth: {
          mode: 'sassKey',
          sassKey: 'YOUR_SASS_KEY',
          projectToken: 'YOUR_TOKEN',
        },
        locale: 'fr', // optional — defaults to 'en'
      }}
    >
      <Dashboard />
    </AssetPickerProvider>
  );
}

import { useAssetPicker } from '@scaleflex/asset-picker/react';

function ImageSelector() {
  const picker = useAssetPicker();

  const handleClick = async () => {
    try {
      const assets = await picker.open({ multiSelect: true });
      console.log('Selected:', assets);
    } catch {
      console.log('User cancelled');
    }
  };

  return <button onClick={handleClick}>Choose images</button>;
}

The promise resolves with the selected Asset[] on confirm, and rejects with 'cancelled' when the user closes without selecting. Note: promise mode returns only assets — use callback mode with onSelect(assets, folders) if you need folder data.

function VideoSelector() {
  const picker = useAssetPicker();

  return (
    <button
      onClick={() =>
        picker.open({
          forcedFilters: { type: { values: ['video'] } },
          onSelect: (assets) => console.log(assets),
          onCancel: () => console.log('Cancelled'),
        })
      }
    >
      Choose video
    </button>
  );
}

Any AssetPickerConfig property passed to open() is merged with (and overrides) the base config from the provider:

// Base config has multiSelect: false
// This call overrides it to true and adds a forced filter
const assets = await picker.open({
  multiSelect: true,
  forcedFilters: { type: { values: ['image'] } },
});

interface UseAssetPickerReturn {
  open(overrides?: OpenOptions): Promise<Asset[]>;
  close(): void;
  isOpen: boolean;
}

Pure helper functions for working with Asset objects. Exported from the main entry point — no React required.

import {
  getAltText,
  getCdnUrl,
  getAssetWidth,
  getAssetHeight,
  getAssetDimensions,
  isTranscoded,
  getTranscodedUrl,
  getBestVideoUrl,
  isVideo,
  isImage,
  isAudio,
} from '@scaleflex/asset-picker';

const alt = getAltText(asset); // uses first available language
const alt = getAltText(asset, 'fr'); // prefers French title

Resolution priority: meta.alt > meta.title (string or localized Record<string, string>) > filename without extension.

The simplest way to theme the picker is via the brandColor config option. It accepts a hex colour string and applies it as the primary accent across all UI elements.

picker.config = {
  auth: {
    /* ... */
  },
  brandColor: '#6366f1', // Indigo
};

If not set, the picker uses the brand colour configured in your Scaleflex project settings.

For fine-grained control, override these CSS custom properties on the <sfx-asset-picker> element or any ancestor. All variables use the --ap- prefix.

asset-picker {
  --ap-primary: #6366f1;
  --ap-primary-foreground: #fff;
  --ap-radius: 12px;
  --ap-modal-max-width: 1400px;
}

These are the keys used in enabledFilters, defaultFilters, and forcedFilters.

Only some of them have an entry in the Filters menu. mimetype, folders, resolution, orientation, faces and products are config-only: users cannot add them, and enabledFilters does not govern them — they stay available to defaultFilters / forcedFilters regardless.

Filters used in defaultFilters and forcedFilters use these shapes:

{
  type: 'string',
  values: string[],           // Filter values
  operator?: string,          // Filter operator (default: ':')
  logic?: 'OR' | 'AND',      // Combine logic (default: 'OR')
}

Examples:

// Only images
{ type: 'string', values: ['image'] }

// Only JPEG and PNG
{ type: 'string', values: ['image/jpeg', 'image/png'] }

// Tagged with "hero" or "banner"
{ type: 'string', values: ['hero', 'banner'] }

// Size range: 1 MB to 50 MB (values in bytes as "min..max")
{ type: 'string', values: ['1000000..50000000'] }

{
  type: 'date',
  field: 'created' | 'updated',
  kind: 'preset' | 'after' | 'before' | 'between' | 'specific' | null,
  preset: string | null,     // e.g. 'today', 'last_week', 'last_month'
  from: string | null,       // ISO date string
  to: string | null,         // ISO date string
}

Examples:

// Uploaded in the last month
{
  type: 'date',
  field: 'created',
  kind: 'preset',
  preset: 'last_month',
  from: null,
  to: null,
}

// Modified after a specific date
{
  type: 'date',
  field: 'updated',
  kind: 'after',
  preset: null,
  from: '2025-01-01T00:00:00.000Z',
  to: null,
}

Available date presets: 'today', 'last_week', 'within_week', 'last_month', 'within_month', 'last_year', 'within_year', 'empty', 'non-empty'

All types are exported from the main entry point:

import type {
  AssetPickerConfig,
  AuthConfig,
  SecurityTemplateAuth,
  SassKeyAuth,
  Asset,
  Folder,
  FolderOwner,
  FilterKey,
  AnyFilterKey,
  AnyFilter,
  StringFilter,
  DateFilter,
  Filters,
  FiltersState,
  ViewMode,
  SortBy,
  SortDirection,
  TabKey,
  AssetPickerSelectDetail,
  AssetPickerCancelDetail,
} from '@scaleflex/asset-picker';

The Asset object returned in ap-select events:

interface Asset {
  uuid: string;
  name: string;
  extension: string;
  type: string; // 'image', 'video', 'audio', 'document', ...
  mime?: string; // MIME type
  size: {
    bytes: number;
    pretty: string;
  };
  url?: {
    public: string; // Public URL
    cdn: string; // CDN-optimised URL
    path: string; // Relative path
    permalink?: string; // Permanent link
  };
  created_at: string; // ISO timestamp
  modified_at: string; // ISO timestamp
  tags:
    | Record<string, Array<{ label: string; sid: string }>>
    | Record<string, { label: string; sid: string }>
    | string[];
  labels: string[];
  meta: {
    title?: string | Record<string, string>; // plain or localized by language code
    description?: string;
    alt?: string;
    [key: string]: unknown;
  };
  info: {
    img_type?: string; // Image format (e.g. "jpeg", "png")
    img_w?: number; // Image width (px)
    img_h?: number; // Image height (px)
    duration?: number; // Audio duration (seconds)
    video_duration?: number; // Video duration (seconds)
    video_w?: number; // Video width (px)
    video_h?: number; // Video height (px)
    thumbnail?: string; // Thumbnail URL
    preview?: string; // Preview URL
    video_thumbnail?: string; // Video poster image URL
    video_gif?: string; // Animated GIF preview URL
    image_thumbnail?: string; // Image thumbnail URL
    main_colors?: string[]; // Dominant colours (names)
    main_colors_hex?: string[]; // Dominant colours (hex)
    dominant_color?: string; // Most dominant colour (name)
    dominant_color_hex?: string; // Most dominant colour (hex)
    color_space?: string; // Colour space (e.g. "sRGB")
    metadata?: Record<string, unknown>; // Embedded metadata (EXIF, IPTC, etc.)
    playlists?: Array<{ playlists: string[]; resolution?: string }>; // HLS transcoded playlists
  };
  folder?: {
    uuid: string;
    name: string;
  };
  owner?: {
    uuid: string;
    name: string;
    email: string;
  };
}

interface Folder {
  uuid: string;
  name: string;
  path: string;
  owner?: FolderOwner;
  created_at: string;
  modified_at?: string;
  updated_at?: string;
  count?: {
    files_recursive?: number;
    files_direct?: number;
  };
  size?: {
    total_recursive_bytes?: number;
    total_recursive_pretty?: string;
  };
  visibility?: {
    in_cdn?: { actual: string; set: string };
    in_dam?: { actual: string; set: string };
  };
  meta?: Record<string, unknown>;
  decoration?: {
    highlight_color?: string | null;
    has_custom_preview?: boolean | null;
  };
}

interface FolderOwner {
  uuid: string;
  name: string;
  email: string;
  photo?: string | null;
}

Requires native support for Custom Elements v1, Shadow DOM, and ES2020+. Internet Explorer is not supported.

asset-picker ships from the scaleflex-dam-tools monorepo. Versioning and npm publishing are centralized via Changesets; the CDN bundle is built per-app. From the monorepo root:

pnpm changeset                                    # record the bump (patch/minor/major)
pnpm --filter @scaleflex/asset-picker build:cdn   # → dist-cdn/asset-picker.min.js

Merging to main opens a Changesets "Version Packages" PR; merging that PR publishes to npm. See DEPLOYING.md for the full flow.

If you use Claude Code, this package ships with a ready-made skill that helps Claude add the asset picker to your project — detecting your framework, wiring auth, events, theming, and filters automatically.

Copy the skill into your project so every team member who uses Claude Code gets it:

mkdir -p .claude/skills/integrate-asset-picker
cp node_modules/@scaleflex/asset-picker/.claude/skills/integrate-asset-picker/SKILL.md \
   .claude/skills/integrate-asset-picker/SKILL.md

Commit the .claude/skills/ directory to version control. The skill is now available to everyone on the team.

Install it once for all your projects:

mkdir -p ~/.claude/skills/integrate-asset-picker
cp node_modules/@scaleflex/asset-picker/.claude/skills/integrate-asset-picker/SKILL.md \
   ~/.claude/skills/integrate-asset-picker/SKILL.md

Type /integrate-asset-picker in Claude Code and it will walk you through the full integration — install, config, events, and theming — tailored to your stack (React, Vue, vanilla JS, etc.).

PROPRIETARY — All Rights Reserved.

Copyright © 2025 Scaleflex SAS.

This software and associated documentation are the exclusive property of Scaleflex SAS. No part of this software may be copied, modified, distributed, sublicensed, sold, or otherwise made available to any third party without prior written permission from Scaleflex SAS.

This package is distributed via npm solely for the convenience of licensed customers. Installing or using this package does not grant any licence to use the software. Use is permitted only under a separate written licence agreement with Scaleflex SAS.

Unauthorised use, reproduction, or distribution of this software may result in civil and criminal penalties and will be prosecuted to the maximum extent permitted by law.

For licensing enquiries, contact sales@scaleflex.com.

Made with care by Scaleflex