Using Templates

Get started quickly with pre-built workflow templates, customize them, and share your own

Templates are pre-built workflows that help you get started quickly. Activepieces provides official templates for common use cases, and you can create your own.

Understanding Templates

A template is a reusable workflow blueprint:

// From packages/shared/src/lib/management/template/template.ts
export type Template = {
  id: string,
  name: string,
  type: TemplateType,  // OFFICIAL, SHARED, or CUSTOM
  summary: string,
  description: string,
  tags: TemplateTag[],
  author: string,
  categories: string[],
  pieces: string[],    // Required integrations
  flows: FlowVersionTemplate[],
  status: TemplateStatus  // PUBLISHED or ARCHIVED
}

Template Types

export enum TemplateType {
  OFFICIAL = 'OFFICIAL',  // Created by Activepieces
  SHARED = 'SHARED',      // Shared by community
  CUSTOM = 'CUSTOM'       // Your private templates
}

Official

Verified templates from Activepieces team. Production-ready and well-tested.

Shared

Templates shared by the community. Various quality and use cases.

Custom

Your private templates. Only visible to your team.

Browsing Templates

1. Open Template Gallery

   Navigate to Templates in the main menu.

2. Browse or Search

   Filter templates by:

   // From packages/shared/src/lib/management/template/template.requests.ts
   type ListTemplatesRequestQuery = {
     type?: TemplateType,      // Filter by type
     pieces?: string[],        // Filter by integrations
     tags?: string[],          // Filter by tags
     search?: string,          // Search by name/description
     category?: string         // Filter by category
   }
   

   By Category

   • Sales & CRM
   • Marketing
   • Customer Support
   • HR & Recruiting
   • Data & Analytics
   • Productivity

   By Integration

   • Gmail
   • Slack
   • Google Sheets
   • HubSpot
   • Salesforce
   • And more…

   By Use Case

   • Lead generation
   • Email automation
   • Data synchronization
   • Notifications
   • Report generation
3. Preview Template

   Click on a template to see:

   • Full description
   • Required integrations
   • Visual workflow preview
   • Setup instructions

Using a Template

1. Select Template

   Click Use Template on the template you want.

2. Template is Imported

   The template creates a new flow in your project:

   // From packages/shared/src/lib/management/template/template.ts
   export type FlowVersionTemplate = {
     displayName: string,
     trigger: FlowTrigger,
     valid: boolean,
     schemaVersion: string,
     description?: string,
     notes?: Note[]  // Setup instructions
   }
   

   Connections are not imported. You’ll need to configure authentication.

3. Configure Connections

   Set up required connections:

   1. Click on steps showing connection errors
   2. Select or create connections
   3. Authenticate with services

   // Connections are removed from templates
   // From packages/server/api/src/app/flows/flow-version/flow-version.service.ts
   removeConnectionsAndSampleDataFromFlowVersion(
     flowVersion,
     removeConnectionNames: true,  // Strip connection references
     removeSampleData: true        // Strip sample data
   )
   
4. Customize Settings

   Adjust template settings for your use case:

   • Update recipient emails
   • Change schedule timing
   • Modify data mappings
   • Add or remove steps
5. Test the Flow

   Test with sample data:

   1. Configure trigger with test data
   2. Click Test Flow
   3. Verify all steps execute correctly
   4. Check output data
6. Publish and Enable

   When ready:

   1. Click Publish
   2. Toggle flow to Enabled
   3. Monitor initial runs

Template Structure

Flow Version Template

// Simplified version of FlowVersion for templates
export const FlowVersionTemplate = Type.Composite([
  Type.Omit(FlowVersion, [
    'id',              // Generated on import
    'created',         // Set on import
    'updated',         // Set on import
    'flowId',          // Assigned on import
    'state',           // Always DRAFT
    'updatedBy',       // Set to importer
    'agentIds',        // Recalculated
    'connectionIds',   // Recalculated
    'backupFiles',     // Not included
    'notes'            // Optional
  ]),
  Type.Object({
    description: Type.Optional(Type.String()),  // Template description
    notes: Type.Optional(Type.Array(Note))      // Setup instructions
  })
])

Template Metadata

{
  "name": "Send Welcome Email to New Users",
  "summary": "Automatically send welcome emails when new users sign up",
  "description": "This template monitors your user database and sends personalized welcome emails...",
  "tags": [
    {
      "title": "Popular",
      "color": "#3B82F6",
      "icon": "star"
    },
    {
      "title": "Email",
      "color": "#10B981"
    }
  ],
  "author": "Activepieces Team",
  "categories": ["Marketing", "Customer Engagement"],
  "pieces": [
    "@activepieces/piece-gmail",
    "@activepieces/piece-webhook"
  ]
}

Customizing Templates

Once imported, templates are regular flows you can fully customize:

Common Customizations

Change Recipients

Update email addresses and notification targets:

{
  "input": {
    "to": "[e-mail]",  // Replace template email
    "cc": "[e-mail]"
  }
}

Adjust Schedule

Modify trigger timing:

{
  "trigger": {
    "type": "PIECE",
    "settings": {
      "pieceName": "@activepieces/piece-schedule",
      "triggerName": "cron_expression",
      "input": {
        "cronExpression": "0 9 * * 1-5"  // Weekdays at 9 AM
      }
    }
  }
}

Add Steps

Extend the template with additional steps:

• Add data transformation
• Insert validation logic
• Include error notifications
• Add logging or analytics

Modify Data Mapping

Adjust how data flows between steps:

{
  "input": {
    // Template might use:
    "name": "{{ trigger.body.user.name }}",
    
    // Customize to your data structure:
    "name": "{{ trigger.body.firstName + ' ' + trigger.body.lastName }}"
  }
}

Creating Your Own Templates

Save Flow as Template

1. Build Your Flow

   Create and test a workflow you want to reuse.

2. Clean Up

   Remove project-specific details:

   • Sensitive data
   • Specific email addresses
   • Internal URLs
   • Test connections
3. Add Documentation

   Use flow notes to document:

   • What the template does
   • Required setup steps
   • Configuration instructions
   • Example use cases
4. Export Flow

   Export your flow to create a template:

   1. Open flow settings
   2. Click Export
   3. Save the JSON file
5. Create Template (Optional)

   For platform administrators:

   // From packages/shared/src/lib/management/template/template.requests.ts
   const createTemplateRequest: CreateTemplateRequestBody = {
     name: "Your Template Name",
     summary: "Brief description",
     description: "Detailed explanation...",
     tags: [
       { title: "Automation", color: "#3B82F6" }
     ],
     author: "Your Name",
     categories: ["Productivity"],
     type: TemplateType.CUSTOM,
     flows: [flowVersionTemplate]
   }
   

Template Best Practices

Use Generic Names

Name variables and steps generically:

// Good
"get_user_data"
"send_notification"
"process_items"

// Bad (too specific)
"get_john_smith_data"
"send_to_sales_team"
"process_march_orders"

Document Requirements

Clearly state what’s needed:

{
  "notes": [
    {
      "content": "Setup Instructions:\n1. Connect your Gmail account\n2. Update recipient email in Send Email step\n3. Test with sample data\n4. Enable flow"
    }
  ]
}

Handle Edge Cases

Include error handling:

• Empty arrays
• Missing data
• API failures
• Invalid inputs

Use Meaningful Defaults

Provide sensible default values:

{
  "input": {
    "subject": "New Notification",  // Clear default
    "limit": 10,                     // Reasonable limit
    "timeout": 30000                 // 30 seconds
  }
}

Test Thoroughly

Before sharing:

• Test with various inputs
• Verify error handling
• Check performance
• Document limitations

Popular Template Categories

Sales & CRM

• New lead notifications
• Contact synchronization
• Deal stage updates
• Quote generation
• Sales report automation

Marketing

• Email campaign automation
• Social media posting
• Lead scoring
• Newsletter management
• Analytics reporting

Customer Support

• Ticket creation
• Auto-responses
• Escalation workflows
• Customer feedback collection
• Support metrics tracking

Data & Analytics

• Data synchronization
• Report generation
• Dashboard updates
• Data backup
• ETL pipelines

Template Tags

export type TemplateTag = {
  title: string,
  color: string,  // Hex color
  icon?: string   // Optional icon name
}

Common tags:

Popular

Most used templates

New

Recently added

Advanced

Complex workflows

Quick Start

Easy to set up

Integration

Connects multiple services

Automation

Fully automated workflows

Sharing Templates

Internal Sharing

Share templates within your organization:

1. Export Flow: Export as JSON
2. Share File: Send to team members
3. Import: Team members import the JSON
4. Configure: Each user sets up connections

Community Sharing

Share with the Activepieces community:

1. Prepare Template: Clean and document thoroughly
2. Submit: Share on community forums
3. Review: Community reviews and tests
4. Publish: Added to template gallery

Only share templates that don’t contain sensitive information or proprietary logic.

Template Limitations

Templates do not include:

• Connection credentials
• Sample data
• Run history
• Version history
• User-specific settings
• Project-specific configurations

You must configure these after importing.

Troubleshooting Templates

Template Import Fails

Problem: Error when importing template.

Solutions:

• Verify JSON is valid
• Check required pieces are available
• Ensure you have necessary permissions
• Try importing to different project

Missing Integrations

Problem: Template requires pieces you don’t have.

Solutions:

• Install required pieces
• Contact administrator for piece installation
• Find alternative template
• Modify template to use available pieces

Validation Errors After Import

Problem: Template imports but shows validation errors.

Reasons:

• Missing connections (expected)
• Piece versions incompatible
• Schema migration issues

Solutions:

• Configure connections (normal)
• Update piece versions
• Check for deprecation warnings

Template Doesn't Work As Expected

Problem: Template executes but doesn’t produce expected results.

Check:

• Connection authentication
• Data structure matches expectations
• All required configuration completed
• Trigger is properly set up

Finding the Right Template

1. Define Your Goal

   What do you want to automate?

   • What triggers the workflow?
   • What actions should happen?
   • What services are involved?
2. Search Templates

   Use specific keywords:

   • Integration names (“Gmail”, “Slack”)
   • Actions (“send email”, “create ticket”)
   • Use cases (“lead notification”, “daily report”)
3. Review Requirements

   Check if you have:

   • Required integrations
   • Necessary permissions
   • Access to services
   • Technical skills needed
4. Compare Options

   If multiple templates match:

   • Review complexity
   • Check recency (newer is often better)
   • Read descriptions carefully
   • Look at author (official vs. community)
5. Start Simple

   If new to Activepieces:

   • Choose simpler templates first
   • Look for “Quick Start” tags
   • Avoid “Advanced” templates initially
   • Build understanding gradually

Next Steps

Building Flows

Learn to build custom workflows

Publishing

Publish your customized template

Versioning

Manage template versions

Best Practices

Workflow best practices