# How to Export and Import Flows in ZazzyAgent

A [ZazzyAgent](http://zazzyagent.com) flow can represent a significant amount of work.

You may have spent hours creating:

*   Messages
    
*   Buttons
    
*   Conditions
    
*   User Input
    
*   Labels
    
*   Sequences
    
*   API connections
    
*   Branches
    
*   Actions
    

You may therefore want to save a copy outside the platform.

ZazzyAgent provides flow **Export and Import** functionality for this purpose.

The current flow-management interface supports exporting flows as JSON and importing them back into a bot.

## Why export a flow?

Export can be useful for:

*   Backup
    
*   Reuse
    
*   Migration
    
*   Testing
    
*   Version control
    
*   Moving a workflow between environments
    

## What is exported?

The flow is exported as a **JSON file**.

JSON is a structured format that represents the flow configuration.

## Export a flow

Open the flow-management area.

Find the flow you want to export.

Open its action menu.

Choose:

**Export**

The current flow-management interface provides an export action for flows.

## Save the JSON file

Save the exported file somewhere secure.

Use a useful filename.

For example:

```text
lead-qualification-v1.json
```

rather than:

```text
flow.json
```

## Why use version names?

If you later make changes, you can keep:

```text
lead-qualification-v1.json
lead-qualification-v2.json
lead-qualification-v3.json
```

This creates a simple history of your automation.

## Import a flow

To import a flow into a bot:

Open the flow-management options.

Choose the Flow Import option.

Upload the JSON file.

The current platform's flow-management workflow provides Flow Import for previously exported JSON files.

## Import into a test bot first

When possible, import into a test environment before using it in production.

This allows you to check whether:

*   Flow structure is intact.
    
*   Actions still point to the right resources.
    
*   Templates are correct.
    
*   External connections are correct.
    
*   URLs are correct.
    

## Important: imported flow doesn't mean every external dependency is ready

A flow may refer to resources outside the JSON structure.

For example:

*   WhatsApp templates
    
*   API credentials
    
*   External URLs
    
*   Connected accounts
    
*   Labels
    
*   Sequences
    
*   Custom fields
    

After import, inspect those dependencies.

## Check templates

If the flow uses a specific WhatsApp template, verify that the destination bot has the appropriate template available.

You may need to remap or reconfigure channel-specific resources.

## Check custom fields

Make sure the imported logic points to the correct fields.

For example:

> Budget

should still point to the intended custom field.

## Check labels

Verify that labels used by the flow exist and represent the intended customer classification.

## Check sequences

Verify that sequence actions point to the correct sequence.

You don't want an imported flow to start the wrong follow-up campaign.

## Check API integrations

This is particularly important.

If the flow contains an API integration, don't assume the same API configuration exists in the target bot/account.

Check:

*   Endpoint
    
*   Authentication
    
*   Parameters
    
*   Response mapping
    

## Check URLs

Open all important external links.

For example:

*   Booking page
    
*   Website
    
*   Product page
    
*   Payment page
    

Make sure they still point to the intended destinations.

## Use export as a backup

Before making major changes to a production flow, exporting a copy can provide a recovery point.

For example:

```text
Production Flow
      ↓
Export
      ↓
production-before-edit.json
      ↓
Make changes
```

If something goes wrong, you have a saved copy of the previous configuration.

## Export before major redesigns

Good times to export include:

*   Before changing triggers
    
*   Before replacing large branches
    
*   Before modifying API logic
    
*   Before redesigning a lead workflow
    
*   Before major template changes
    

## Import for testing

Suppose you want to experiment with:

> Version 2 of your booking flow.

You can export the existing version and create a test copy.

Then make the changes in the test version.

## Export vs Duplicate

### Duplicate

Creates a copy inside ZazzyAgent.

### Export

Creates an external JSON file.

Use Duplicate for quick in-platform reuse.

Use Export when you want a portable backup or file-based version.

## Export vs Copy to Other Bot

### Copy to Other Bot

Moves/copies a flow directly between connected bots.

### Export

Creates a JSON file that can later be imported.

The current flow-management interface supports all three operations separately: duplicate, copy and export/import.

## Keep exported files organized

For a larger automation library, use folders such as:

```text
ZazzyAgent Flows/
   Sales/
   Support/
   Booking/
   Lead Generation/
   Archive/
```

Then keep versioned exports.

## Don't blindly import production flows

A flow can contain powerful actions.

Before activating an imported flow, check:

*   Who receives leads?
    
*   Which sequence starts?
    
*   Which API is called?
    
*   Which template is sent?
    
*   Which labels are added?
    
*   Which URL is opened?
    

## Test after importing

The import is not the end.

Run a complete test.

```text
Import
  ↓
Review
  ↓
Save
  ↓
Test Trigger
  ↓
Test Every Branch
  ↓
Check Actions
  ↓
Activate
```

## Common problems

### Import fails

Check that the JSON file is valid and was exported from a compatible flow configuration.

### Flow imports but behaves differently

Review external dependencies and channel-specific configuration.

### Buttons point somewhere unexpected

Check the duplicated/imported connections.

### API stops working

Review the API configuration and credentials.

### Labels or sequences don't behave correctly

Check whether the destination bot has the required resources and whether the imported references are still correct.

## Use exports as version history

For serious automation projects, a simple naming system can help:

```text
booking-v1.json
booking-v2-after-api.json
booking-v3-production.json
```

You now have a record of your automation versions outside the dashboard.

## The main idea

**Duplicate** when you want another copy inside ZazzyAgent.

**Copy to Other Bot** when you want to reuse a flow across another connected bot.

**Export** when you want a portable JSON copy.

**Import** when you want to bring that JSON flow back into a bot.

These tools make larger automation projects much easier to manage.
