> This page is for Postman Flows, version Latest (v12) (default).
> For other versions, use one of these documentation indexes:
> - Latest (v12) (default): https://learning.postman.com/flows/latest-v-12/llms.txt
> - v11: https://learning.postman.com/flows/v11/llms.txt

> For clean Markdown content of this page, append .md to this URL. For the complete documentation index, see https://learning.postman.com/llms.txt.

# Loops overview

Loops are a basic element of control flow in computer programming that Postman Flows supports. As a visual programming environment, Flows has its own design patterns that you need to know to make looping structures work for you.

> **Info**
>
> Starting in Postman version 11.47.2, you can't connect blocks to pass data into loops within flow. Instead, use a **Create Variable** block to store a value, and then insert an inline **Get Variable** block in the block that needs to use that value.

## Loops with the Repeat block

In Flows, here's the most basic design pattern for a loop:

1. Begin with a [**Repeat**](/flows/reference/blocks/repeat/) block. Use a **Number** block to set the `Count` input to the number of times you want Flows to iterate through the loop.

2. Connect a block that does work (for example, an [**Evaluate**](/flows/reference/blocks/evaluate/) block) to the **Repeat** block.

3. Optionally, add more blocks that do work, connecting them together in a series.

4. Connect a [**Collect**](/flows/reference/blocks/collect/) block to the last of the blocks from the previous step.

5. Connect a [**Display**](/flows/reference/blocks/output-display/) block to the **Collect** block.

This loop repeats the specified number of times. There's no way to break out of the loop.

Here's how the loop will look:

![Design pattern for basic loop with Repeat](https://assets.postman.com/postman-docs/v11/flows-loops-external-data-repeat-v11.49.0.jpg)

## Loops with the For block

Since the [**For**](/flows/reference/blocks/for/) block iterates over a list, you need to provide a list to its input.

1. Begin with a [**List**](/flows/reference/blocks/list/) block. Alternatively, you can use an **HTTP Request** block to pass in a list from an API.

2. Connect a **For** block to the **List** block.

3. Connect a block that does work (for example, an **Evaluate** block) to the **For** block.

4. Optionally, add more blocks that do work, connecting them together in a series.

5. Connect a **Collect** block to the last of the blocks from the previous step.

6. Connect a **Display** block to the **Collect** block.

This loop goes all the way through the list - there's no way to break out. Nor can you start in the middle.

Here's how the loop will look:

![Design pattern for basic loop with For](https://assets.postman.com/postman-docs/v11/flows-loops-external-data-for-v11.49.0.jpg)

## Best practices for working with loops

When planning and creating loops in flows, consider the following facts and principles:

* **Collect** blocks are great for synchronizing loops, because the flow will wait until all data has been collected before continuing.

* Don't try to create a variable within a loop. Flows treat variables as constants that can only be set once.

* In Flows, you can construct a double **For** loop that's equivalent to a nested loop in programming languages like Python or JavaScript. For example, if a value *X* in the outer loop is needed to process other values in the inner loop, use an **Evaluate** block in the outer loop to map *X* to each item you're sending through to the inner loop. (See the TypeScript [map()](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html) function.)

## Alternatives to loops

Flows can filter and map data. For computational efficiency, consider doing this with TypeScript in **Evaluate** blocks rather than with loops.

Here's an example flow whose source data is a list of JSON objects that describe water and oil wells. The goal is to reveal correlations between a well's elevation and its status.

* The first **Evaluate** block filters out all the wells whose elevation falls outside of a range of interest, thus selecting a manageable subset of wells to investigate. The range of interest is from 700 to 960 feet, inclusive, and the following expression performs the filtering:

  ```javascript
  tableOfWells.filter(
  (row) => row.Elevation >= 700 && row.Elevation <= 960);
  ```

* The second **Evaluate** block maps values from the data's `Elevation` and `Status of Well` fields to new JSON objects and outputs these as a list ordered by elevation from low to high. Displaying the transformed data as a table makes correlations easier to spot. The following expression performs the mapping and ordering:

  ```javascript
  wellList = wells.map((row) => ({["Elevation"]: row["Elevation"],["Status": row["Status of Well"]}));
  wellList.sort((a, b) => a.Elevation - b.Elevation);
  ```

You could produce the same result using loops. But when operating on large data sets, you'll get better performance using **Evaluate** blocks with the TypeScript methods `filter()`, `map()`, and `sort()`.

![Design pattern for basic loop with For](https://assets.postman.com/postman-docs/v11/flows-loops-filter-and-map-v11.52.2.jpg)