LearnOverpass

https://osmlab.github.io/learnoverpass/en/docs
Admin
LearnOverpass provides documentation and tutorials for the Overpass API Query Language (Overpass...
Tokens:8,014
Snippets:48
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Overpass QL Union Block Query Syntax and Examples

Source: https://osmlab.github.io/learnoverpass/en/docs/block-queries/union

Demonstrates the syntax and usage of the Union block statement in Overpass QL. It explains how to combine results from multiple queries, redirect output to a named set, and provides practical examples.

```Overpass QL
(statement_1; statement_2; …)[->.result_set];
```

```Overpass QL
(node[name="Foo"];way[name="Foo"];);
```

```Overpass QL
(node[name="Foo"];way[name="Foo"];)->.a;
```

```Overpass QL
(
node
[amenity=drinking_water]
(47.06,15.42,47.09,15.48);
node
[tourism=hotel]
(47.06,15.42,47.09,15.48);
);
out;
```

--------------------------------

### Overpass QL 'out' Action Documentation

Source: https://osmlab.github.io/learnoverpass/en/docs/actions/print

Comprehensive documentation for the Overpass QL 'out' action, including its various parameters for controlling output format, verbosity, and data inclusion. It covers different output modifiers and provides examples for common use cases.

```APIDOC
OverpassQL Out Action:

The 'out' action prints the results of an Overpass QL query. It accepts various parameters to modify the output.

Syntax:
out [options];

Parameters:
- Verbosity:
  - ids: Print only the IDs of the elements.
  - skel: Print information necessary for geometry (coordinates for nodes, member IDs for ways/relations).
  - body: Print all information needed to use the data (tags for all elements, roles for relation members).
  - tags: Print only IDs and tags for each element, excluding coordinates or members.
  - meta: Print all known information about elements, including version, changeset ID, timestamp, and user data.

- Derived Information:
  - bb: Adds the bounding box of each element. For ways, it's the bounding box of all nodes. For relations, it's the bounding box of all members.
  - center: Adds the center of the bounding box to ways and relations. Note: The center point is not guaranteed to lie inside the polygon.
  - geom: Add the full geometry to each object (coordinates for nodes, 'nd' members for ways/relations).
    - geom(south,west,north,east): Limits coordinates produced to those within the specified bounding box.

- Sorting:
  - asc: Sort results by object ID (default).
  - qt: Sort results by quadtile index (geographically faster).

- Limiting:
  - [non-negative integer]: Specifies the maximum number of elements to print. Default is no limit.

Examples:

===default===
( // Rio de Janeiro's Christ the Redeemer peak
  node[name=Corcovado][natural=peak];
  >;
);
out;

===meta===
( // Rio de Janeiro's Christ the Redeemer peak
  node[name=Corcovado][natural=peak];
  >;
);
out meta;

===bounding box===
( // Rio de Janeiro's Christ the Redeemer peak
  way(141708228);
  >;
);
out bb;

===limit===
( // Rio de Janeiro's Christ the Redeemer peak
  way(141708228);
  >;
);
// only print 20 nodes from the way
out 20;

===center===
( // Rio de Janeiro's Christ the Redeemer peak
  way(141708228);
  >;
);
// print center (not centroid) of the polygon
out center;

===combination===
( // Rio de Janeiro's Christ the Redeemer peak
  way(141708228);
  >;
);
// print multiple times using different modifiers
out geom;
out center;
out bb;

Input Set Modification:
The input set can be modified by prepending a variable name before 'out'.
Example: `out geom;` can become `my_set out geom;` to apply the action only to elements in `my_set`.
```

--------------------------------

### LearnOverpass: Foreach loop for iterating over elements

Source: https://osmlab.github.io/learnoverpass/en/docs/block-queries/foreach

Demonstrates the `foreach` block statement in LearnOverpass. It iterates over an input set, executing a block of statements for each element. The example shows how to process nodes belonging to ways.

```overpassql
way[name="Foo"];
foreach(
  (
    ._;
    >;
  );
  out;
);

```

--------------------------------

### Overpass QL: Intersecting Named Sets

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/input-set

An example showing how to define named input sets for areas, filter nodes within those areas, and then select nodes present in the intersection of these sets. Includes output commands.

```Overpass QL
// get area Alpe and Cividale
(area[name="Cividale del Friuli"])->.Cividale;
(area[name="Julijske Alpe"])->.Alpe;
(node[power=pole](area.Cividale))->.Cividale_nodes;
(node[power=pole](area.Alpe))->.Alpe_nodes;
// print out nodes that are present in both areas (intersection)
node.Alpe_nodes.Cividale_nodes;
out body qt;
(relation[name="Cividale del Friuli"];>;);
out body;
out skel qt;
(relation[name="Julijske Alpe"];>;);
out body;
out skel qt;
```

--------------------------------

### Pivot Filter with Area Definition and Output

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/pivot

An example showing how to define a specific area (Greater London), store it in a named set, use the 'pivot' filter to retrieve its defining relation, and then output its geometry.

```overpassql
// determine area for Greater London and store it to .London_area
area[name="London"][admin_level=6][boundary=administrative]->.London_area;
// convert back to relations using the pivot filter
rel(pivot.London_area);
// output the geom
out geom;
```

--------------------------------

### Overpass QL Combined Query with Recurse Filter

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/recurse

A practical example of an Overpass QL query that combines fetching elements from different bounding boxes and then uses the 'recurse' filter (node(w)) to select specific child nodes from the ways found.

```OverpassQL
// get nodes and ways from different bounding boxes.
(
  node[amenity=cafe]
  (0, 0, 5, 5);
  way[highway=cycleway]
  (47.0682, 15.4429, 47.0686, 15.444);
);
// but only print out the nodes that are
// childnodes from the ways of input set
node(w);
out;
```

--------------------------------

### Overpass QL Query Example: Finding Peaks in Dolomites Area

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/area

A practical example demonstrating how to first find a specific area (Dolomites) using tags and then query for nodes tagged as natural=peak within that identified area.

```Overpass QL
// search the area of the Dolmites
area
[place=region]
["region:type"="mountain_area"]
["name:en"="Dolomites"];
out body;
// get all peaks in the area
node
[natural=peak]
(area);
out body qt;
```

--------------------------------

### LearnOverpass: Foreach loop for adjacent nodes

Source: https://osmlab.github.io/learnoverpass/en/docs/block-queries/foreach

An example demonstrating the `foreach` loop in LearnOverpass to find and print adjacent nodes around a set of bank nodes. It uses `around` filter and assigns loop elements to a variable.

```overpassql
// get all bank nodes in coordinates
(
  node[amenity=bank]
  (47.0678,15.4401658,47.069,15.4501658);
  >;
);
// foreach bank node, print out adjacent nodes
foreach->.bank_set(
  node(around.bank_set:15)->.adjacent_set;
  (.adjacent_set;);
  out meta;
);

```

--------------------------------

### Item Query as Filter: Banks in Bounding Box

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/item

An example showing the item statement used as a filter. It defines a set of nodes representing banks within a specific bounding box, assigns it to '.bank_set', and then prints the contents of this set.

```overpass-ql
(node[amenity=bank]
 (47.06,15.42,47.09,15.48);
)->.bank_set;
//here we print the bank_set by passing the .bank_set query
.bank_set out;
```

--------------------------------

### Overpass QL: Recurse Up within Node Filter

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/recurse-up

An example demonstrating the recurse up query used within a node filter, combined with output redirection. This complex query finds nodes within a bounding box, then recursively finds related ways and relations.

```overpassql
(
node(47.0678,15.440,47.069,15.444);
<;
);
out;
```

--------------------------------

### Overpass QL Newer Filter Example

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/newer

This snippet demonstrates the Overpass QL 'newer' filter, which retrieves elements that have been changed since a specified date and time. The filter requires a date string in quotes and must be part of a larger query statement.

```Overpass QL
(node."(newer:\"2012-09-14T07:00:00Z\");>;);
out;

```

--------------------------------

### Overpass QL Bounding Box Filter

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/bbox

The bbox-query filter in Overpass QL selects all elements within a specified bounding box defined by southern, western, northern, and eastern limits (latitude and longitude). It takes four floating-point numbers as arguments. The example shows how to query nodes within a given bounding box.

```Overpass QL
node
(47.065,15.425,47.07,15.43); // a bbox-filter
out;

```

--------------------------------

### Overpass QL: Recurse Up with Specified Input Set

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/recurse-up

Illustrates how to define a specific input set for the recurse up standalone query using prefix notation. This allows targeting the query to elements within a predefined set.

```overpassql
.a <;
```

--------------------------------

### Overpass QL Input Set Filter Syntax

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/input-set

Demonstrates the basic syntax for using the input set filter in Overpass QL, including selecting from the default set and named sets.

```Overpass QL
node._;

node.a;

node.a.b;
```

--------------------------------

### Overpass QL Recurse Filter Basics

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/recurse

Demonstrates the fundamental usage of the recurse filter in Overpass QL, showing how to select related elements (nodes, ways, relations) based on different traversal directions (forward from ways, backward from nodes, etc.) and input set modifications.

```OverpassQL
// Examples with default input set:
node(w);        // select child nodes from all ways of the input set
node(r);        // select node members of relations of the input set
way(bn);        // select parent ways for all nodes from the input set
way(r);         // select way members of relations from the input set
rel(bn);        // select relations that have node members from the input set
rel(bw);        // select relations that have way members from the input set
rel(r);         // select all members of type relation from all relations of the input set
rel(br);        // select all parent relations of all relations from the input set

// Example with modified input set:
node(w.foo);
```

--------------------------------

### Overpass QL Basics and Execution State

Source: https://osmlab.github.io/learnoverpass/en/docs/index

Explains the fundamental structure of Overpass QL queries, including statement termination, imperative semantics, and the concept of execution state managed by default and named sets.

```APIDOC
Overpass QL Syntax and Semantics:

Overpass QL is a C-style query language for the Overpass API.
- Queries are divided into statements, each ending with a semicolon (;).
- It uses imperative semantics: statements are processed sequentially.

Execution State:
- Consists of a default set (named '_') and potentially other named sets.
- Sets can contain nodes, ways, relations, and areas.
- Input is implicitly read from '_' unless a named set is specified.
- Results are written to the default set '_' or explicitly to named sets.
- Set names can include letters, digits, and underscores, but must not start with a digit.
- Assigning a result to an existing set replaces its previous contents.
- Sets have global visibility.

Statement Types:
- Actions: Statements with effects outside the execution state (e.g., print).
- Standalone Queries: Complete statements on their own.
- Filters: Used within query statements to select elements based on criteria.
- Block Statements: Group statements for disjunctions or loops.
- Settings: Configure output format and other global options.
```

--------------------------------

### LearnOverpass: Foreach loop with custom input set

Source: https://osmlab.github.io/learnoverpass/en/docs/block-queries/foreach

Shows how to specify a custom input set for the `foreach` loop in LearnOverpass using postfix notation (e.g., `foreach.a`). This allows iterating over a previously defined variable.

```overpassql
foreach.a(...);

```

--------------------------------

### Overpass QL: Recurse Up with Output Set Redirection

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/recurse-up

Shows how to redirect the result set of the recurse up standalone query to a named output set using postfix notation. This is useful for chaining operations or storing intermediate results.

```overpassql
< ->.b;
```

--------------------------------

### Overpass QL: Recurse Up with Input and Output Sets

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/recurse-up

Combines specifying an input set and redirecting the output set for the recurse up standalone query. This provides a flexible way to process and manage data flow in Overpass QL queries.

```overpassql
.a < ->.b;
```

--------------------------------

### Overpass QL: Basic Filtering with BBox

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/tag

Demonstrates a simple Overpass QL query to filter nodes by a specific tag and apply a bounding box filter.

```Overpass QL
// Filter and only get nodes that are banks.
node[amenity=bank]
(47.06,15.42,47.09,15.48); // a bbox-filter
out;
```

--------------------------------

### Overpass QL: Basic Recurse Up Standalone Query

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/recurse-up

Demonstrates the fundamental usage of the recurse up standalone query in Overpass QL. It takes an input set and returns related elements such as ways containing nodes from the input, and relations containing nodes or ways from the input.

```overpassql
<;
```

--------------------------------

### LearnOverpass: Foreach loop with custom input and loop set

Source: https://osmlab.github.io/learnoverpass/en/docs/block-queries/foreach

Illustrates using both custom input and loop element assignment for the `foreach` statement in LearnOverpass. The `foreach.a->.b` syntax specifies the input set as 'a' and assigns the current loop element to variable 'b'.

```overpassql
foreach.a->.b(...);

```

--------------------------------

### Item Query: Default Input Set

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/item

Demonstrates the most common usage of the item query, which reproduces its input set. This is particularly useful for union statements to include the default input set.

```overpass-ql
._;
```

--------------------------------

### Overpass QL Block Statements: Loops and Disjunctions

Source: https://osmlab.github.io/learnoverpass/en/docs/index

Explains block statements, including union and foreach loops, used for grouping queries and enabling conditional logic or iteration.

```APIDOC
Overpass QL Block Statements:

Union:
  - Combines results from multiple query statements into a single set.
  - Syntax:
    ( statement1; statement2; ... );
  - Description: Allows for the logical OR operation between different query parts. All results from the enclosed statements are merged.
  - Example:
    (
      node["amenity"="restaurant"];
      node["amenity"="cafe"];
    );
    out;

Difference:
  - Computes the set difference between two query statements.
  - Syntax:
    ( statement1; - statement2; );
  - Description: Returns elements that are in the first statement's result but not in the second statement's result.
  - Example:
    (
      node["amenity"];
      - node["amenity"="restaurant"];
    );
    out;

For-each loop (foreach):
  - Iterates over elements in a set and executes a query block for each element.
  - Syntax:
    foreach <set> -> .<loop_var> {
      <query_block>;
    }
  - Description: Enables iterative processing of query results. The loop variable '.<loop_var>' represents the current element in each iteration.
  - Example:
    node["amenity"="school"]->.schools;
    foreach .schools -> .school {
      (.school; <<;);
      out;
    }
  - Related: Block statements are fundamental for structuring complex queries and managing intermediate results.
```

--------------------------------

### Overpass QL Filters: Tag, Location, and Input Set

Source: https://osmlab.github.io/learnoverpass/en/docs/index

Documents filters for selecting elements based on tags, geographical bounding boxes, polygons, areas, and input sets.

```APIDOC
Overpass QL Filters:

By Tag:
  - Selects elements based on their key-value pairs.
  - Syntax:
    [key=value];
    [key~"regex"];
    [key!=value];
    [key~"regex"@case);
    [key~"regex"@case|case);
  - Description: Filters elements that have specific tags. Supports exact matches, regular expressions (case-sensitive or insensitive), and negation.
  - Example:
    node["amenity"="restaurant"];
    way[name~"^Main.*"];

Bounding Box (bbox):
  - Selects elements within a specified geographical rectangular area.
  - Syntax:
    (bbox);
    (lat1,lon1,lat2,lon2);
  - Description: Filters elements whose coordinates fall within the given latitude and longitude boundaries.
  - Example:
    node(48.85,2.35,48.86,2.36);

Polygon (poly):
  - Selects elements within a custom polygonal boundary.
  - Syntax:
    (poly:"polygon_data");
  - Description: Filters elements contained within a complex polygon defined by a string of coordinates.
  - Example:
    way(poly:"@48.85,2.35,48.86,2.36,48.85,2.35");

By Input Set:
  - Filters elements that are present in a specified input set.
  - Syntax:
    (set_name);
  - Description: Restricts the current query to elements that are already in a previously defined named set.
  - Example:
    node["highway"]->.highways;
    way(highways);
    out;

By Element Id:
  - Selects elements directly by their unique identifiers.
  - Syntax:
    (id1,id2,id3);
  - Description: Retrieves specific elements when their IDs are known.
  - Example:
    node(12345,67890);

Related Filters: Recurse (n, w, r, bn, bw, br), Relative to other elements (around), Newer, By date of change (changed), By user (user, uid), By area (area), Area pivot (pivot).
```

--------------------------------

### Overpass QL: Key and Value Match Regular Expressions

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/tag

Selects elements where both the tag key and its value match specified regular expressions. The syntax is `~"key_regex"~"value_regex"`.

```Overpass QL
node[~"^addr:.*$"~"^Foo$"];    /* finds addr:* tags with value exactly "Foo" */
node[~"^addr:.*$"~"^Foo"];     /* finds addr:* tags with value starting with "Foo" */
node[~"^addr:.*$"~"Foo$"];     /* finds addr:* tags with value ending with "Foo" */
node[~"^addr:.*$"~"Foo"];      /* finds addr:* tags with value containing the substring "Foo" */
node[~"^addr:.*$"~"."];        /* finds addr:* tags with any value */
```

--------------------------------

### Item Query: Custom Input Set

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/item

Illustrates the usage of the item query with a custom named input set (e.g., '.a'). This allows specific sets to be referenced.

```overpass-ql
.a;
```

--------------------------------

### Overpass QL Actions: Print Statement

Source: https://osmlab.github.io/learnoverpass/en/docs/index

Details the 'print' statement, which is classified as an action and is essential for outputting query results from the execution state.

```APIDOC
Overpass QL Actions:

Print Statement (out):
  - The primary action statement used to output query results.
  - Syntax:
    out [body|ids|geom|skel|count];
    out count;
    out ids;
    out body;
    out geom;
    out skel;
  - Description: Specifies the format of the output. 'body' includes tags and geometry, 'ids' only IDs, 'geom' only geometry, 'skel' minimal data, and 'count' the number of elements.
  - Example:
    [out:json];
    node["amenity"="restaurant"](48.85,2.35,48.86,2.36);
    out body;
  - Related: Other actions might exist for different output formats or operations.
```

--------------------------------

### Overpass QL Standalone Queries

Source: https://osmlab.github.io/learnoverpass/en/docs/index

Covers standalone query types that can form complete statements, such as retrieving individual items or performing recursive up operations.

```APIDOC
Overpass QL Standalone Queries:

Item Query:
  - Retrieves a specific element by its ID.
  - Syntax:
    node(id);
    way(id);
    relation(id);
    area(id);
  - Description: Fetches a single element (node, way, relation, or area) based on its unique identifier.
  - Example:
    node(12345);
    out;

Recurse Up (<):
  - Retrieves parent elements (ways or relations) that contain a given element.
  - Syntax:
    <;
    ( <; );
  - Description: Used within a query block to find elements that contain the current set of elements. Useful for finding the ways or relations a node belongs to.
  - Example:
    node(id:12345);
    ( <; );
    out;
  - Related: Recurse Down (>) is used to find elements contained within the current set.
```

--------------------------------

### Overpass QL Area Filter Basic Usage

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/area

Demonstrates the basic syntax for using the 'area' filter to select nodes, ways, and relations that are contained within the current input set of areas.

```Overpass QL
node(area);
way(area);
rel(area);
```

--------------------------------

### Item Query in Union: Default Input Set + Recurse Down

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/item

Shows how the item query, when combined with recurse down ('>;'), can be used within a union statement to include all items from the default input set along with the recurse down result.

```overpass-ql
(._;
 >;
);
```

--------------------------------

### Overpass QL Filters: Spatial and Temporal

Source: https://osmlab.github.io/learnoverpass/en/docs/index

Details filters for selecting elements based on proximity, recency, change date, and user attribution.

```APIDOC
Overpass QL Filters (Continued):

Relative to other elements (around):
  - Selects elements within a specified radius of a reference element.
  - Syntax:
    around:<radius>[,<element_id>];
    around:<radius>,<lat>,<lon>;
  - Description: Finds elements within a given distance (in meters) from a specific point or element.
  - Example:
    node(around:1000, 48.85, 2.35);

Recurse (n, w, r, bn, bw, br):
  - Navigates through element relationships (nodes in ways, ways/nodes in relations).
  - Syntax:
    nwr;
    nw;
    nr;
    bw;
    br;
    bn;
  - Description: Allows traversal of the OpenStreetMap data model. 'nwr' finds nodes, ways, and relations related to the current set. 'bw' finds ways belonging to relations, 'bn' finds nodes belonging to ways.
  - Example:
    way["highway"]->.roads;
    ( .roads; <; ); // Find ways and the relations they belong to
    out;

Newer:
  - Selects elements that have been modified more recently than a specified timestamp or another element.
  - Syntax:
    newer:<timestamp>;
    newer:<element_id>;
  - Description: Filters elements based on their last modification date.
  - Example:
    node["amenity"="cafe"](newer:1678886400);

By date of change (changed):
  - Selects elements modified within a specific date range.
  - Syntax:
    changed(<timestamp_start>, <timestamp_end>);
  - Description: Retrieves elements that were modified between two given Unix timestamps.
  - Example:
    node["shop"](changed:1678886400, 1678972800);

By user (user, uid):
  - Selects elements created or modified by a specific user.
  - Syntax:
    user:"username";
    uid:12345;
  - Description: Filters elements based on the OSM user who last modified them.
  - Example:
    node["tourism"](user:"osmuser");

By area (area):
  - Selects elements that are within a specified administrative or custom area.
  - Syntax:
    area[name="CityName"];
    area(id:12345);
  - Description: Uses predefined or custom areas to filter elements geographically.
  - Example:
    node["amenity"](area["name"="Berlin"]);

Area pivot (pivot):
  - Selects elements that are part of a specified area, often used for complex spatial queries.
  - Syntax:
    pivot(area_id);
  - Description: A more advanced filter for spatial relationships, often used in conjunction with other filters.
  - Example:
    node(pivot:12345);

Related Filters: By Tag, Bounding Box, Polygon, By Input Set, By Element Id, Relative to other elements (around).
```

--------------------------------

### Item Query in Union: Custom Input Set + Recurse Down

Source: https://osmlab.github.io/learnoverpass/en/docs/standalone-queries/item

Demonstrates using a custom named input set (e.g., '.a') with the item query within a union statement, including the recurse down operation on that set.

```overpass-ql
(.a;
 .a >;
);
```

--------------------------------

### Overpass QL Recurse Filter with Roles

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/recurse

Illustrates how to use the recurse filter in Overpass QL with specific roles to refine the selection of related elements from relations. It covers filtering by role name and searching for empty roles.

```OverpassQL
// Examples with default input set and roles:
node(r:"role");        // select node members of relations of the input set with a specific role
way(r:"role");         // select way members of relations from the input set with a specific role
rel(bn:"role");        // select relations that have node members from the input set with a specific role
rel(bw:"role");        // select relations that have way members from the input set with a specific role
rel(r:"role");         // select all members of type relation from all relations of the input set with a specific role
rel(br:"role");        // select all parent relations of all relations from the input set with a specific role

// Example with modified input set and role:
node(r.foo:"role");

// Example with empty roles:
node(r:"");
node(r.foo:"");
```

--------------------------------

### Overpass QL: Value Matches Regular Expression (~)

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/tag

Selects elements where a tag's value matches a specified regular expression. Supports basic regex patterns and case-insensitive matching with the 'i' flag.

```Overpass QL
node["name"~"^Foo$"];    /* finds exactly "Foo" */
node["name"~"^Foo"];     /* finds anything that starts with "Foo" */
node["name"~"Foo$"];     /* finds anything that ends with "Foo" */
node["name"~"Foo"];      /* finds anything that contains the substring "Foo" */
node["name"~"."];        /* finds anything, equal to the previous variant */

/* Case-insensitive matching */
node["name"~"^Foo$",i];    /* finds "foo", "FOO", "fOo", "Foo" etc. */
```

--------------------------------

### Overpass QL Area Filter with Modified Input Set

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/area

Shows how to use the 'area' filter when the input set has been modified, referencing areas by a label (e.g., '.a') derived from a previous step.

```Overpass QL
node(area.a);
way(area.a);
rel(area.a);
```

--------------------------------

### Pivot Filter with Input Set Alias

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/pivot

Illustrates how to apply the 'pivot' filter to a specific input set, identified by an alias (e.g., '.a'), allowing for more complex query chaining.

```overpassql
way(pivot.a);
rel(pivot.a);
```

--------------------------------

### Overpass QL: Value Does Not Match Regular Expression (!~)

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/tag

Selects elements where a tag's value does NOT match a specified regular expression. Supports basic regex patterns and case-insensitive matching with the 'i' flag.

```Overpass QL
node["name"!="Foo"]; /* Negation of exact match */
node["name"!~"Foo"]; /* Negation of regex match */
node["name"!~"Foo",i]; /* Negation of case-insensitive regex match */
```

--------------------------------

### Overpass QL User Filter

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/user

Selects elements last touched by a specified user. Supports filtering by username (user:"...") or user ID (uid:...). The filter is applied within a query statement and has no input set.

```overpassql
node(user:"Steve");
node(uid:1);
node._(user:"HeinerSchaefer");
```

--------------------------------

### Basic Pivot Filter Usage

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/pivot

Demonstrates the fundamental usage of the 'pivot' filter to select the element that defines the outline of an area. This can be a way or a relation.

```overpassql
way(pivot);
rel(pivot);
```

--------------------------------

### Overpass QL Difference Block Statement

Source: https://osmlab.github.io/learnoverpass/en/docs/block-queries/difference

Explains the syntax and functionality of the difference block statement in Overpass QL. It allows for set difference operations between two sub-statements, returning elements from the first that are not in the second. Results can be redirected to named sets.

```Overpass QL
(statement_1; - statement_2;)[->.result_set];
```

```Overpass QL
(node[name="Foo"]; - node(50.0,7.0,51.0,8.0););
```

```Overpass QL
(node[name="Foo"]; - node(50.0,7.0,51.0,8.0);)->.a;
```

```Overpass QL
(
node[amenity]( 47.06, 15.435, 47.07, 15.44);
-node[amenity](47.064, 15.435, 47.066, 15.44);
);
out;
```

--------------------------------

### Overpass QL Area Filter by ID

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/area

Illustrates how to use the 'area' filter to select elements within a specific area identified by its Overpass API virtual ID. This bypasses the current input set.

```Overpass QL
node(area:2400000001);
way(area:2400000001);
rel(area:2400000001);
```

--------------------------------

### Overpass Filter: By Tag (Equals/Not Equals)

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/tag

Filters OSM elements by tag key-value pairs using exact matches (=) or inequality (!=). Quotes are optional for simple keys/values but required for values with digits, whitespace, or special characters. Handles querying for empty values or keys using regular expressions.

```APIDOC
Overpass Filter: By Tag (Equals/Not Equals)

Filters OSM elements by tag key-value pairs.

Syntax:
key=value
key!=value
key~regex
key!~regex
~regex~value
~regex!=value
~regex~regex
~regex!=regex

Variants:

### Equals (=, !=)
Selects elements where the tag with the given key has a specific value or not.

Examples (all equivalent):
```
node["name"="Foo"];
node[name=Foo];
node['name'="Foo"];
node[name="Foo"];
node["name"='Foo'];
```

Quotes are needed for values with digits, whitespace, or special characters:
```
node["name"="Foo Street"];
node["name"='Foo Street'];
node[name="Foo Street"];
```

Querying for empty values (not supported by '='):
```
node[power=""];          // not supported
node[power~"^$"];        // use regular expression instead
```

Querying for empty key values (not supported by key=value):
```
node[~"^$"~"."];         // find nodes with empty key ("" and any value)
```

NB: Overpass Turbo Wizard may auto-convert ""="" accordingly.

### Exists
Selects elements that have a tag with a certain key and an arbitrary value.

Syntax:
key

Examples:
```
node["name"];
node['name'];
node[name];
```
```

--------------------------------

### Overpass Filter: By Tag (Exists)

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/tag

Filters OSM elements to select those that possess a specific tag key, regardless of its value. This is a shorthand for checking tag presence.

```APIDOC
Overpass Filter: By Tag (Exists)

Selects all elements that have a tag with a certain key and an arbitrary value.

Syntax:
key

Examples:
```
node["name"];
node['name'];
node[name];
```
```

--------------------------------

### Filter OSM Elements by ID (Overpass QL)

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/element-id

Selects OSM elements (node, way, relation, area) by their unique identifier. The syntax involves specifying the element type followed by the ID in parentheses. The result set is determined by the entire query statement, not just the individual filter.

```overpassql
node(1);
way(1);
rel(1);
area(1);

// Example: Get node with ID 1170494282 and print it
node(1170494282);
out;
```

--------------------------------

### Overpass QL: Changed Filter

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/changed

Selects elements modified between two dates. If one date is provided, it defaults to the current timestamp. This filter can be more performant than the 'newer' filter and can function as a standalone query.

```Overpass QL
node._(changed:"2012-09-14T07:00:00Z");
```

```Overpass QL
node.\_(changed:"2012-09-14T07:00:00Z","2012-09-14T07:01:00Z");
out;
```

--------------------------------

### Overpass QL Polygon Filter (poly)

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/polygon

The 'poly' filter in Overpass QL selects elements of a chosen type that are located inside a given polygon. The polygon is defined by a sequence of latitude and longitude coordinates. It can be applied to nodes, ways, and relations.

```OverpassQL
(poly:"latitude_1 longitude_1 latitude_2 longitude_2 latitude_3 longitude_3 …");
```

```OverpassQL
node(poly:"50.7 7.1 50.7 7.2 50.75 7.15");
way(poly:"50.7 7.1 50.7 7.2 50.75 7.15");
rel(poly:"50.7 7.1 50.7 7.2 50.75 7.15");
```

```OverpassQL
(node(poly:"50.73 7.13 50.73 7.17 50.75 7.15");>;);
out;
```

--------------------------------

### Overpass QL: around Filter

Source: https://osmlab.github.io/learnoverpass/en/docs/filters/around

Selects elements within a specified radius around input elements or coordinates. Can be used with an input set or directly with latitude/longitude. A radius of 0 is useful for way intersection tests.

```APIDOC
Overpass QL around Filter:

Syntax:
(around[.input_set]:radius)
(around:radius,latitude,longitude)

Description:
Selects all elements within a certain radius (in meters) around the elements in the input set. If coordinates are provided, they are used instead of the input set. The input set can be modified with an adapted prefix notation. The result set is specified by the whole statement. A radius of 0 can be used for a way intersection test on outer/inner points.

Parameters:
  .input_set: Optional. Specifies the input set to use for the radius calculation.
  radius: The radius in meters (float).
  latitude: Latitude coordinate (float).
  longitude: Longitude coordinate (float).

Examples:
// Select nodes within 100m of the current input set
node(around:100.0);
way(around:100.0);
rel(around:100.0);

// Select nodes within 100m of a specific input set 'a'
node(around.a:100.0);

// Select nodes within 100m of specific coordinates
node(around:100.0,50.7,7.1);
way(around:100.0,50.7,7.1);
rel(around:100.0,50.7,7.1);

// Example: Find all cinemas in Bonn which are at most 100m away from bus stops
// area[name="Bonn"];
// node(area)[highway=bus_stop];
// node(around:100)[amenity=cinema];
// out;

// Get all ways from a 50m radius from coordinates 51.1788435, -1.826204 (Stonehenge)
// (way(around:50, 51.1788435,-1.826204);>;);
// out body;
```
Tokens:
Raw