# Infrastructure Ground Motion Screening (`solutionssmart/infrastructure-ground-motion-screening`) Actor

Find infrastructure near Copernicus EGMS ground-motion signals. Screen railways, bridges, warehouses, industrial, and commercial assets for further review.

- **URL**: https://apify.com/solutionssmart/infrastructure-ground-motion-screening.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 completed infrastructure screens

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What this Actor does

Infrastructure Ground Motion Screening finds infrastructure near vertical ground-motion signals in Copernicus European Ground Motion Service (EGMS) data. Enter a city and search area, or an exact bounding box. The Actor returns a short list of nearby rail, bridge, warehouse, industrial, and commercial assets for review.

It is a desktop screening tool for geotechnical, civil, and infrastructure teams. Use it to decide where a site review, asset-owner check, or detailed monitoring may be warranted. It does not assess structural condition, predict failure, estimate damage, or provide safety, insurance, or valuation advice.

The current EGMS release covers 2020-2024. Treat the results as a historical baseline, not live monitoring.

### How it works

The Actor resolves the selected location, retrieves EGMS L3 vertical data for the area, and filters points by vertical velocity. It then retrieves nearby OpenStreetMap infrastructure and assigns each filtered point to the nearest eligible asset within the selected proximity radius. This prevents one point from generating a row for every adjacent rail segment or building.

The default 100 m radius is intended for L3 screening. A result is a proximity candidate, not proof that the asset itself is moving. The dataset includes the association distance, confidence, motion value, and source links so the candidate can be checked quickly.

### Run a screen

1. Select **City or address** and enter a city and country, such as `Hannover, Germany`. Use **Custom bounding box** only when you need exact coordinates.
2. Set the search area. Start with 9 km2. Larger searches can take longer because EGMS L3 data is distributed in large tiles.
3. Set the motion threshold. The default is 2 mm/year. Raise it to limit results to stronger signals.
4. Set infrastructure proximity. The default is 100 m.
5. Run the Actor and review the matched-asset dataset and `OUTPUT` summary.

For a custom bounding box, enter `minLongitude`, `minLatitude`, `maxLongitude`, and `maxLatitude` as WGS84 coordinates. The maximum supported area is 650 km2.

### Input example

```json
{
  "locationMode": "city",
  "city": "Hannover, Germany",
  "areaKm2": 9,
  "motionThresholdMmYear": 2,
  "assetSearchBufferMeters": 100
}
```

### Results

Each `matched_asset` item contains the asset type, its OpenStreetMap reference, a Google Maps link, the EGMS motion evidence, and the proximity evidence. OpenStreetMap address, operator, website, and reference values appear only when they are mapped for that asset.

```json
{
  "record_type": "matched_asset",
  "asset_id": "osm-way-667756286",
  "asset": {
    "name": "Unnamed railway",
    "asset_type": "railway",
    "google_maps_url": "https://www.google.com/maps/search/?api=1&query=52.358993,9.722131",
    "operator": "infra Infrastrukturgesellschaft Region Hannover"
  },
  "motion": {
    "measurement_points": 1,
    "median_velocity_mm_year": -2.2
  },
  "matching": {
    "match_method": "distance_buffer",
    "median_distance_meters": 32.2,
    "asset_match_confidence": 0.502
  },
  "screening_priority": "WATCH"
}
```

`WATCH` items are preliminary. In particular, a one-point result or a `distance_buffer` match needs corroboration before it is used to prioritize engineering work.

Velocity values follow the EGMS `ORTHO-UP` convention. Review the sign and magnitude together with the local context.

The `OUTPUT` record reports the run status, selected area, location, EGMS and OpenStreetMap counts, timings, and memory use. A completed run can return:

- `NO_OSM_ASSETS`: no selected OpenStreetMap infrastructure was found.
- `NO_EGMS_DATA`: no EGMS product was available for the area and release.
- `NO_SIGNIFICANT_MOTION`: no EGMS point met the motion threshold.
- `NO_ASSET_POINT_ASSOCIATIONS`: filtered points were not within the selected proximity radius of an eligible asset.

### Data and access

The Actor uses EGMS L3 vertical `ORTHO-UP` data for its standard screen. L3 does not include temporal coherence, so its stated quality basis is velocity uncertainty. The Actor uses OpenStreetMap data to identify infrastructure and link each result to the mapped object.

No Copernicus API credentials are required from the user. EGMS access is handled by the Actor.

Results use Copernicus Land Monitoring Service information and OpenStreetMap data. Copernicus data is provided under the applicable Copernicus data policy. OpenStreetMap data is available under the [Open Database License](https://www.openstreetmap.org/copyright).

City searches use [OpenStreetMap Nominatim](https://www.openstreetmap.org/copyright). Include a country in the city input to avoid ambiguous matches. High-volume deployments should use a Nominatim-compatible geocoder through `GEOCODER_URL`.

The Actor charges one `screen-completed` event after it has processed EGMS data. A completed screen can have no asset matches. Check the Actor's Pricing tab before running it; pricing is configured in Apify and may change.

### FAQ

#### Does a result mean the asset has a ground-motion problem?

No. It means a filtered EGMS point was nearest to that selected OpenStreetMap asset within the chosen screening radius. Review the motion value, point count, match method, association distance, and local context.

#### Why is the dataset empty?

Read the `OUTPUT` status. Try a larger area, a lower motion threshold, or a wider proximity radius only when that radius still makes sense for the asset type and screening purpose.

#### Why is the result from 2024 rather than today?

EGMS is a published ground-motion product, not a live feed. This Actor currently uses the 2020-2024 release. Recent SAR monitoring needs a separate processing or provider workflow.

#### Why does the log say the EGMS cache is disabled?

`WARN Cache disabled because this run cannot create the egms-asset-match-egms-cache key-value store.` means the run does not have permission to create the optional shared cache. The Actor continues by downloading the required EGMS data for that run, so the warning does not affect the result. Repeated runs may take longer because they cannot reuse cached data.

#### Can I use my own asset inventory?

Not in version 1.0. The Actor currently uses OpenStreetMap infrastructure only.

### Support and feedback

For questions, support, or product ideas, email <solutionssmart2026@gmail.com>. Please leave an Apify Store review after you have used the Actor, and share feedback on the results, inputs, or workflow.

# Actor input Schema

## `locationMode` (type: `string`):

Use a city or address for the simplest search. Choose Custom bounding box only for an exact area.

## `city` (type: `string`):

Include the country when possible, for example Hannover, Germany.

## `areaKm2` (type: `number`):

Square search area centred on the location. Start with 9 km2 for a focused screen.

## `motionThresholdMmYear` (type: `number`):

2 mm/year is the recommended first-pass threshold. Increase it to show only stronger signals.

## `assetSearchBufferMeters` (type: `number`):

100 m is recommended for L3 screening. Results within this radius are proximity candidates, not confirmed asset condition.

## `minLongitude` (type: `number`):

Western boundary in WGS84.

## `minLatitude` (type: `number`):

Southern boundary in WGS84.

## `maxLongitude` (type: `number`):

Eastern boundary in WGS84.

## `maxLatitude` (type: `number`):

Northern boundary in WGS84.

## Actor input object example

```json
{
  "locationMode": "city",
  "city": "Hannover, Germany",
  "areaKm2": 9,
  "motionThresholdMmYear": 2,
  "assetSearchBufferMeters": 100
}
```

# Actor output Schema

## `matchedAssets` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "city": "Hannover, Germany"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/infrastructure-ground-motion-screening").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "city": "Hannover, Germany" }

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/infrastructure-ground-motion-screening").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "city": "Hannover, Germany"
}' |
apify call solutionssmart/infrastructure-ground-motion-screening --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solutionssmart/infrastructure-ground-motion-screening"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IhFUYV0ec8PIidtfM/builds/iWwt0oabcpRc9dM20/openapi.json
