# How to Create a Dynamic List Using API Data in ZazzyAgent

A normal list is useful when the options are fixed.

For example:

*   Mumbai
    
*   Delhi
    
*   Pune
    
*   Bengaluru
    

But what if the available options change constantly?

For example:

> Available appointments today.

The answer might change every few minutes.

This is where a **Dynamic List** becomes useful.

## What is a dynamic list?

A dynamic list creates interactive options using data provided by another source.

A common architecture is:

```text
Customer
   ↓
HTTP API
   ↓
Fresh Data
   ↓
Dynamic List
   ↓
Customer selects an option
```

The current Flow Builder supports dynamic lists driven by external API data and mapped fields.

## When should you use a dynamic list?

Use one when the choices change.

Examples:

*   Available appointments
    
*   Available products
    
*   Delivery slots
    
*   Service locations
    
*   Agents
    
*   Restaurants
    
*   Hotel rooms
    
*   Classes
    
*   Courses
    
*   Inventory
    

## Example: Appointment availability

Customer:

> I want to book today.

Your automation calls:

**Appointment API**

The API returns:

```text
10:00 AM
1:00 PM
4:00 PM
```

ZazzyAgent generates the list.

The customer chooses:

> 1:00 PM

The workflow continues with that selection.

## Step 1: Create the API

Create an HTTP API configuration that returns the information you need.

See [How to Use HTTP API in ZazzyAgent Flow Builder](https://blog.zazzyagent.com/how-to-use-http-api-zazzyagent-flow-builder).

## Step 2: Store the response

Configure your workflow so the API response can be used by the dynamic list.

The current dynamic-list workflow uses structured response data stored in a custom field before mapping the list values.

## Step 3: Prepare your data

Your API might return data like:

```json
[
  {
    "name": "10:00 AM",
    "description": "Available",
    "id": "1000"
  },
  {
    "name": "1:00 PM",
    "description": "Available",
    "id": "1300"
  },
  {
    "name": "4:00 PM",
    "description": "Available",
    "id": "1600"
  }
]
```

Your list can use:

**name**

as the visible title.

**description**

as supporting text.

**id**

as an internal value.

## Step 4: Configure the dynamic list

Open the appropriate list component in Flow Builder.

Configure the source data.

Map the fields returned by the API to the fields expected by the list.

## Step 5: Set the visible title

Choose which API field the customer should see as the main option.

For example:

> name

produces:

**10:00 AM**

## Step 6: Add a description

If your data contains a description, use it to provide additional context.

Example:

**10:00 AM**

> Available

or:

**10:00 AM**

> Limited availability

## Step 7: Map the selected value

The list should return enough information to identify what the customer selected.

For example:

> 1300

could represent the 1:00 PM slot.

You can then use that value in the next API call.

## Example: Booking process

```text
Customer
   ↓
Choose Date
   ↓
HTTP API
   ↓
Available Slots
   ↓
Dynamic List
   ↓
Customer selects 1:00 PM
   ↓
Booking API
   ↓
Confirmation
```

This is much better than manually creating a fixed list of appointment times.

## Example: Product availability

Your API returns:

```text
Product A
Product B
Product C
```

The customer sees:

**Product A**

**Product B**

**Product C**

The list updates whenever your underlying system changes.

## Example: Delivery slots

The API returns today's available windows:

```text
9 AM – 12 PM
12 PM – 3 PM
3 PM – 6 PM
```

The customer chooses one.

The next API call can attempt to reserve it.

## Dynamic list vs normal list

### Normal list

You define the options manually.

Best for:

*   Fixed categories
    
*   Permanent choices
    
*   Small menus
    

### Dynamic list

The options come from changing data.

Best for:

*   Availability
    
*   Inventory
    
*   Real-time records
    
*   Customer-specific results
    

## Dynamic list vs carousel

Use:

**Dynamic List**

when the customer mainly needs to choose from text.

Use:

**Carousel**

when the customer needs to browse visual cards.

## Dynamic list and customer-specific data

A particularly powerful use case is retrieving different options for different customers.

For example:

> Show appointments for Rahul's assigned sales representative.

The API can return only the relevant results.

Then the dynamic list displays those options.

## Dynamic list and conditions

You can also filter the result before displaying it.

For example:

**Customer Type = Enterprise**

→ Enterprise appointment options.

**Customer Type = Standard**

→ Standard appointment options.

## Dynamic list and AI

AI can help determine what the customer wants.

For example:

Customer:

> I want to book tomorrow afternoon.

AI identifies:

**Date = Tomorrow**

**Time Preference = Afternoon**

The automation then calls the availability API and displays the relevant dynamic list.

## Common dynamic-list problems

### List is empty

Check:

*   API response
    
*   Stored custom field
    
*   JSON structure
    
*   Mapping
    

### Wrong titles appear

Check the title-field mapping.

### Wrong option is selected

Check the ID/value mapping.

### API returns data but list doesn't display it

Check whether the returned data is in the expected structure.

### Options are outdated

Check when the API is being called.

The list is only as current as the source data being retrieved.

## Test with realistic data

Don't test only with:

```text
Option 1
Option 2
```

Use real API response structures.

Also test:

*   Empty result
    
*   One result
    
*   Multiple results
    
*   Unexpected value
    
*   API failure
    

## The architecture to remember

```text
External System
      ↓
HTTP API
      ↓
Structured Response
      ↓
Custom Field / Mapping
      ↓
Dynamic List
      ↓
Customer Choice
      ↓
Next Action
```

This turns [ZazzyAgent](http://app.zazzyagent.com) into an interface for your live business data.