# 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.
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. See [About flows before Postman 11.47.2](/docs/postman-flows/build-flows/structure/loops/overview/#about-flows-before-postman-11472).
## Loops with the Repeat block
In Flows, here's the most basic design pattern for a loop:
1. Begin with a [**Repeat**](/docs/postman-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**](/docs/postman-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**](/docs/postman-flows/reference/blocks/collect/) block to the last of the blocks from the previous step.
5. Connect a [**Display**](/docs/postman-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:
## Loops with the For block
Since the [**For**](/docs/postman-flows/reference/blocks/for/) block iterates over a list, you need to provide a list to its input.
1. Begin with a [**List**](/docs/postman-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:
## 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 especially when operating on large data sets, you'll get better performance using **Evaluate** blocks with the TypeScript methods `filter()`, `map()`, and `sort()`.
## About flows before Postman 11.47.2
In some earlier versions of Postman, flows have a **Deploy** button that when clicked would generate a webhook and deploy the flow at that URL. If you have flows that were deployed in this way and that contain loops, they will continue to run normally unless you redeploy them. When redeployed, they may fail. To prevent this, before you redeploy such flows, revise the loops to pass data using **Get Variable** and **Create Variable** blocks.
Webhooks in flows are deprecated and will be sunset on February 11, 2026. Webhooks in flows will stop working after that date. To learn how to migrate flows with webhooks to flows running in the cloud, see the [Webhook migration guide](/docs/postman-flows/build-flows/troubleshoot/webhook-migration-guide/).
[Deployable flows](/docs/postman-flows/build-flows/structure/actions/) have always required **Get Variable** and **Create Variable** to pass data into loops. Thus, while it's a breaking change for older flows deployed with webhooks, this change doesn't affect flows running in the cloud.
Here's an example that correctly uses **Get Variable** and **Create Variable** blocks to pass data into a loop. This method has always been supported. The data being passed is the string "Hello".
Here's another version of the same example, this time using the obsolete approach that was supported only in flows created in Postman version 11.47.1 or earlier. Don't do this!
