# Google Shopping Germany Scraper (`scrapyspider/google-shopping-germany-scraper`) Actor

Scrape Google Shopping Germany (google.de) for product listings including prices, ratings, reviews, and merchant details — no account, login, or cookies required.

- **URL**: https://apify.com/scrapyspider/google-shopping-germany-scraper.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### Google Shopping Germany Scraper

Scrape Google Shopping Germany (google.de) for product listings with prices, ratings, reviews, and merchant details — no account or cookies needed. Built-in marketplace filtering surfaces D2C brands by excluding Amazon, eBay, Otto, and other aggregators.

#### Key Highlights

- 🇩🇪 Focused exclusively on the German market — google.de with `hl=de`, `gl=de`, and EUR pricing
- 🚫 Built-in marketplace exclusion filters out Amazon, eBay, Otto, Zalando, and price comparison sites automatically
- 🔍 Multi-query support — run dozens of search keywords in a single execution
- ⭐ Extracts review scores, review counts, and sponsored/organic classification for every product
- 🧹 Automatic deduplication removes repeat merchant domains across queries
- 💰 Price range filtering lets you target specific market segments (min/max EUR)
- 📦 Export to JSON, CSV, or Excel with one click from the Apify dataset

#### What data does it extract?

Each product in the output dataset includes the following fields:

- **Product info:** `title`, `price`, `currency` (EUR), `imageUrl`
- **Reviews:** `reviewsCount` (number of reviews), `reviewsScore` (star rating out of 5.0)
- **Merchant info:** `source`, `merchantName`
- **Search context:** `query` (original search keyword), `isSponsored` (paid listing flag)

Results are stored in an Apify dataset and can be downloaded as JSON, CSV, or Excel.

#### Use Cases

**D2C Brand Discovery:** Identify independent, direct-to-consumer brands selling on Google Shopping Germany by filtering out major marketplaces and aggregators.

**Price Monitoring:** Track product prices across German merchants for specific keywords over time. Use price range filters to focus on your target segment.

**Competitor Research:** Analyze which merchants appear for your product keywords, whether they use sponsored placements, and how their ratings compare.

**Market Analysis:** Understand product availability, pricing distribution, and merchant landscape for any product category in the German e-commerce market.

**Lead Generation:** Build lists of D2C brand websites and merchant domains from Google Shopping results for sales outreach and partnership opportunities.

#### How to Use

1. Open the Actor in **Apify Console** and click **Start**.
2. Enter your search keywords in the **Search Queries** field (e.g., "feuchtigkeitscreme", "vitamin c serum").
3. Optionally adjust **Excluded Merchants** and **Exclusion Keywords** to fine-tune filtering.
4. Set **Max Pages per Query** (1–10) depending on how many results you need (~10 products per page).
5. Click **Start** and wait for the run to complete — most runs finish in under 2 minutes.
6. Download your results from the **Dataset** tab as JSON, CSV, or Excel.

#### Input Parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `queries` | Array of strings | Yes | — | Search keywords for Google Shopping Germany. Each keyword runs a separate search. |
| `exclusionKeywords` | Array of strings | No | `["refill", "sample", "trial", "probe", "tester", "used", "refurbished", "gebraucht"]` | Terms to exclude from product titles (case-insensitive). |
| `excludedMerchants` | Array of strings | No | `["amazon", "ebay", "otto", "zalando", "idealo", "preisvergleich", "geizhals", "billiger", "check24"]` | Merchants to filter out by name or domain. |
| `maxPages` | Integer (1–10) | No | `3` | Pages to scrape per query. Each page returns ~10 products. |
| `enableDeduplication` | Boolean | No | `true` | Remove duplicate products from the same merchant domain across queries. |
| `includeSponsored` | Boolean | No | `true` | Include paid/sponsored product listings in results. |
| `includeOrganic` | Boolean | No | `true` | Include organic (non-sponsored) product listings in results. |
| `minPrice` | Number | No | `0` | Minimum product price in EUR. Set to 0 for no minimum. |
| `maxPrice` | Number | No | `0` | Maximum product price in EUR. Set to 0 for no maximum. |

#### Output Sample

```json
[
  {
    "title": "Neutrogena Hydro Boost Aqua Creme",
    "price": 8.79,
    "currency": "EUR",
    "reviewsCount": 3428,
    "reviewsScore": 4.7,
    "source": "apodiscounter.de",
    "merchantName": "apodiscounter.de",
    "merchantUrl": null,
    "productUrl": null,
    "imageUrl": null,
    "query": "feuchtigkeitscreme",
    "isSponsored": true
  },
  {
    "title": "Caudalie VinoHydra Intensive Feuchtigkeitscreme",
    "price": 19.99,
    "currency": "EUR",
    "reviewsCount": 3125,
    "reviewsScore": 4.7,
    "source": "Douglas.de",
    "merchantName": "Douglas.de",
    "merchantUrl": null,
    "productUrl": null,
    "imageUrl": null,
    "query": "feuchtigkeitscreme",
    "isSponsored": false
  }
]
````

#### Pricing

This is a **free Actor** — you only pay for Apify platform usage (compute and proxy). A typical run scraping 3 queries × 3 pages costs approximately **$0.01–$0.05** in platform credits.

The [Apify free tier](https://apify.com/pricing) includes $5 of monthly credits, which is enough for hundreds of scraping runs.

#### Technical Notes

- No account, login, or cookies required
- Uses the `GOOGLE_SERP` proxy group (German residential IPs)
- Targets Google Shopping Germany specifically: `google.de` with `hl=de` and `gl=de` parameters
- German market focus with EUR pricing and DE merchant results
- Built on `CheerioCrawler` for fast, lightweight HTML parsing
- Data is scraped live from Google Shopping on every run — always up to date
- Skipped items (excluded merchants, duplicates, price out of range) are logged to the `SKIPPED_ITEMS_LOG` key-value store for debugging

#### Integrations

- **Export formats:** Download results as JSON, CSV, or Excel directly from the Apify dataset tab
- **REST API:** Access results programmatically via the [Apify API](https://docs.apify.com/api/v2) for automated workflows
- **Automation platforms:** Connect to Make, Zapier, or n8n through Apify's built-in integrations

#### Support

Have questions or found a bug? Reach out:

- **Email:** ScrapySpider@protonmail.com
- **Website:** [ScrapySpider.com](https://scrapyspider.com)
- **Apify:** Open an issue on this Actor's page
- **Response time:** Within 24–48 hours on weekdays

# Actor input Schema

## `queries` (type: `array`):

List of product keywords to search on Google Shopping Germany. Each query runs a separate search.

## `exclusionKeywords` (type: `array`):

Terms to exclude from product titles. Products containing any of these words (case-insensitive) will be skipped.

## `excludedMerchants` (type: `array`):

Merchant names or domains to exclude. Products from these merchants will be filtered out. By default, major marketplaces are excluded for D2C discovery.

## `maxPages` (type: `integer`):

Number of Google Shopping result pages to scrape per query. Each page returns ~10 products. Max 10.

## `enableDeduplication` (type: `boolean`):

Remove duplicate products from the same merchant domain across queries.

## `includeSponsored` (type: `boolean`):

Include paid/sponsored product listings in results.

## `includeOrganic` (type: `boolean`):

Include organic (non-sponsored) product listings in results.

## `minPrice` (type: `number`):

Minimum product price in EUR. Set to 0 for no minimum.

## `maxPrice` (type: `number`):

Maximum product price in EUR. Set to 0 for no maximum.

## Actor input object example

```json
{
  "queries": [
    "feuchtigkeitscreme",
    "vitamin c serum",
    "face cleanser"
  ],
  "exclusionKeywords": [
    "refill",
    "sample",
    "trial",
    "probe",
    "tester"
  ],
  "excludedMerchants": [
    "amazon",
    "ebay",
    "otto",
    "zalando",
    "idealo"
  ],
  "maxPages": 3,
  "enableDeduplication": true,
  "includeSponsored": true,
  "includeOrganic": true,
  "minPrice": 0,
  "maxPrice": 0
}
```

# 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 = {
    "queries": [
        "feuchtigkeitscreme",
        "vitamin c serum"
    ],
    "exclusionKeywords": [
        "refill",
        "sample",
        "trial",
        "probe",
        "tester"
    ],
    "excludedMerchants": [
        "amazon",
        "ebay",
        "otto",
        "zalando",
        "idealo"
    ],
    "maxPages": 3,
    "enableDeduplication": true,
    "includeSponsored": true,
    "includeOrganic": true,
    "minPrice": 0,
    "maxPrice": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/google-shopping-germany-scraper").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 = {
    "queries": [
        "feuchtigkeitscreme",
        "vitamin c serum",
    ],
    "exclusionKeywords": [
        "refill",
        "sample",
        "trial",
        "probe",
        "tester",
    ],
    "excludedMerchants": [
        "amazon",
        "ebay",
        "otto",
        "zalando",
        "idealo",
    ],
    "maxPages": 3,
    "enableDeduplication": True,
    "includeSponsored": True,
    "includeOrganic": True,
    "minPrice": 0,
    "maxPrice": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/google-shopping-germany-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "feuchtigkeitscreme",
    "vitamin c serum"
  ],
  "exclusionKeywords": [
    "refill",
    "sample",
    "trial",
    "probe",
    "tester"
  ],
  "excludedMerchants": [
    "amazon",
    "ebay",
    "otto",
    "zalando",
    "idealo"
  ],
  "maxPages": 3,
  "enableDeduplication": true,
  "includeSponsored": true,
  "includeOrganic": true,
  "minPrice": 0,
  "maxPrice": 0
}' |
apify call scrapyspider/google-shopping-germany-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapyspider/google-shopping-germany-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Germany Scraper",
        "description": "Scrape Google Shopping Germany (google.de) for product listings including prices, ratings, reviews, and merchant details — no account, login, or cookies required.",
        "version": "1.0",
        "x-build-id": "5Tl7FJVfXHXnmtccM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapyspider~google-shopping-germany-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapyspider-google-shopping-germany-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapyspider~google-shopping-germany-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapyspider-google-shopping-germany-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapyspider~google-shopping-germany-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapyspider-google-shopping-germany-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of product keywords to search on Google Shopping Germany. Each query runs a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "exclusionKeywords": {
                        "title": "Exclusion Keywords",
                        "type": "array",
                        "description": "Terms to exclude from product titles. Products containing any of these words (case-insensitive) will be skipped.",
                        "default": [
                            "refill",
                            "sample",
                            "trial",
                            "probe",
                            "tester",
                            "used",
                            "refurbished",
                            "gebraucht"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludedMerchants": {
                        "title": "Excluded Merchants",
                        "type": "array",
                        "description": "Merchant names or domains to exclude. Products from these merchants will be filtered out. By default, major marketplaces are excluded for D2C discovery.",
                        "default": [
                            "amazon",
                            "ebay",
                            "otto",
                            "zalando",
                            "idealo",
                            "preisvergleich",
                            "geizhals",
                            "billiger",
                            "check24"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max Pages per Query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of Google Shopping result pages to scrape per query. Each page returns ~10 products. Max 10.",
                        "default": 3
                    },
                    "enableDeduplication": {
                        "title": "Enable Deduplication",
                        "type": "boolean",
                        "description": "Remove duplicate products from the same merchant domain across queries.",
                        "default": true
                    },
                    "includeSponsored": {
                        "title": "Include Sponsored Results",
                        "type": "boolean",
                        "description": "Include paid/sponsored product listings in results.",
                        "default": true
                    },
                    "includeOrganic": {
                        "title": "Include Organic Results",
                        "type": "boolean",
                        "description": "Include organic (non-sponsored) product listings in results.",
                        "default": true
                    },
                    "minPrice": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum product price in EUR. Set to 0 for no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum product price in EUR. Set to 0 for no maximum.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
