Using Marketplace Templates
Find, install, and reuse pre-built integration blueprints from the Celigo Marketplace -- Templates (unlocked, fully editable, no ongoing updates) and Integration Apps (vendor-maintained, upgrade-protected, receive updates). Covers whole-template install versus copying a single element, how connections are mapped rather than copied, the dependency cascade, and when to start from a blueprint instead of building from scratch. Use when browsing the marketplace, installing a template or Integration App, or copying an existing flow, export, import, or connection into your own integration.
- Skill ID
- celigo/ai/using-marketplace-templates
- Publisher
- celigo
- Repository
- ai
- Installs
- 0
- Files
- 1
- Synced
- Sep 23, 2026
Open any RiverX project, open the Skills panel in the chat, and search for this identifier. The files are fetched from the source repository at install time.
celigo/ai/using-marketplace-templatesInstalls these files- SKILL.md
What this skill tells the agent
<!-- TIER:1 -->
Using Marketplace Templates
The Celigo Marketplace is a catalog of pre-built integration blueprints -- packaged flows, exports, imports, connections, and scripts you can browse, install, or reuse instead of building from scratch. Each listing is one of three kinds: a Template, an Integration App (IA), or an AI Agent. Most decisions come down to Templates vs Integration Apps.
Templates vs Integration Apps
Templates are open, customizable blueprints. Every flow, export, import, and script ships into your account as your own editable resource -- rename, restructure, or rewrite anything. The trade-off: templates receive no ongoing updates. A template is a starting point, not a maintained product; if the source application's API changes, you carry the fix.
Integration Apps (IAs) are vendor-maintained, structure-locked products. Their core flows, mappings, and logic are upgrade-protected so Celigo (or a partner) can ship updates without breaking your customizations. The trade-off: you configure only what the IA exposes (settings, mappings, endpoints) and can't rewrite the core -- in exchange you inherit bug fixes and new features over time.
Choosing wrong has opposite failure modes: pick a template when you needed an IA and you own the integration forever with no upstream fixes; pick an IA when you needed a template and you hit the locked-component ceiling the moment you must customize beyond what it exposes. When unsure, list both and compare.
AI Agents are a third listing type -- browse them in the marketplace to see what's available.
Whole Install vs Single-Element Copy
Two distinct operations, separated by intent:
- Whole-template install creates a brand-new integration containing fresh copies of every resource in the blueprint. Intent: "set up the whole integration." This runs in the Celigo Marketplace UI installer on the listing's preview page.
- Single-element copy drops ONE element -- a flow, export, import, connection, or script -- plus everything it depends on, into an integration you already have. Intent: "borrow one piece."
Recognize intent from wording: "install the X template" / "set up X from a template" -> whole install; "copy the Y flow from the X template" / "I just want the customer export" -> single-element copy.
What Gets Copied vs Mapped
When resources land in your account, they fall into two camps:
- Copied -- flows, exports, imports, scripts, lookup caches, and response mappings become fresh resources you own. There is no link back to the blueprint: editing them doesn't touch the source, and editing the source wouldn't touch them.
- Mapped -- connections are never copied. The blueprint's connection ids are placeholders; install and copy resolve each one to a real account connection -- reusing a match (same type + endpoint shape) or creating a new one. Connections are shared resources, so copying them would just duplicate credentials pointing at the same endpoint.
A single-element copy pulls the full dependency cascade: copying a flow brings its exports, imports, scripts, and lookup exports -- each dragging in its connection (mapped) and hook scripts -- so you get a runnable element, not a half-wired fragment.
Quick Reference
Templates vs Integration Apps
| Dimension | Templates | Integration Apps (IAs) |
|---|---|---|
| After install | Fully unlocked -- every resource is yours to edit | Structure-locked -- core flows/mappings/logic are upgrade-protected |
| Ongoing updates | None -- a starting point you maintain | Vendor-maintained -- receives bug fixes and new features |
| Customization | Rename, restructure, rewrite anything | Configure only what the IA exposes (settings, mappings, endpoints) |
| If the source API changes | You fix it yourself | The vendor ships the update |
| Best for | A fast start you'll own and adapt | A supported product you don't need to rewrite |
| Install path | Marketplace UI installer (preview page) | Marketplace UI installer (multi-step wizard) |
| Single-element copy | Supported -- pull one element into your integration | Installed as a whole product |
Whole Install vs Single-Element Copy
| Whole-template install | Single-element copy | |
|---|---|---|
| Result | Brand-new integration with fresh copies of everything | One element (+ its dependencies) added to an existing integration |
| Runs in | Celigo Marketplace UI installer | Marketplace UI (into a chosen integration) |
| Connections | Mapped during the installer | Mapped to existing or newly created connections |
| Use when | You want the entire integration | You want to borrow one piece |
Start From a Blueprint vs Build From Scratch
| Situation | Do this |
|---|---|
| A listing matches your source + destination and you want a fast start you'll own | Install a Template |
| You want a supported, auto-updated product and don't need to rewrite core logic | Install an Integration App |
| You only need one flow or step from an otherwise-unfit blueprint | Copy that single element into your integration |
| No listing matches, or requirements are highly custom | Build from scratch |
Related Skills
- getting-started > Build Order -- where installing from a blueprint fits versus building bottom-up
- managing-integrations -- a whole-template install lands as a new integration you then organize and promote
- configuring-connections > Quick Reference -- connections are mapped, not copied; verify or create the ones an install needs
- building-flows > How to Build a Flow -- edit or extend a flow after it lands in your account
- configuring-exports > Quick Reference -- exports pulled in by the dependency cascade
- configuring-imports > Quick Reference -- imports pulled in by the dependency cascade
- writing-scripts > Quick Reference -- hook scripts copied alongside flows and steps
<!-- TIER:2 -->
How to Use a Marketplace Template
1. Check what already exists
Before installing anything, search the account so you don't duplicate an integration or connection you already have.
celigo account search "<keyword>"2. Browse the marketplace
List catalog entries and note whether each is a Template or an Integration App.
celigo marketplace list
celigo marketplace list --type templateUI (primary): the Marketplace UI is the primary place to browse and install -- open the listing's preview page there.
3. Decide: Template, Integration App, or build from scratch
Use the Quick Reference tables. Key questions:
- Do you need ongoing vendor updates (-> Integration App) or full control (-> Template)?
- Do you need the whole integration (-> install) or one piece (-> copy)?
- Does anything even match (-> otherwise build from scratch)?
4. Preview before you install
Inspect the blueprint's contents and the connections it expects before committing.
celigo templates preview <id> --summary
celigo templates preview <id> --model Connection5. Install a whole template or Integration App
Whole-template and IA installs run in the Celigo Marketplace UI installer on the listing's preview page. The installer walks the multi-step wizard: mapping or creating connections, accepting the license, selecting a plan, and configuration.
More from celigo
Use this skill in a project
Open any RiverX project, search the Skills panel for celigo/ai/using-marketplace-templates, and install it in one click.
