# Globus Scraper — German Grocery Hypermarket Products & Prices (`studio-amba/globus-scraper`) Actor

Scrape products, prices, and stock status from globus.de -- Germany's Globus grocery hypermarket chain. Supports keyword search and category browsing.

- **URL**: https://apify.com/studio-amba/globus-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Globus Scraper

Scrape product data, prices, and stock status from globus.de -- Germany's
Globus grocery hypermarket chain.

### What is Globus Scraper?

Globus runs large-format grocery hypermarkets across Germany, known for a
wide fresh-food range and weekly offer cycles. Their online catalog at
produkte.globus.de exposes structured product data (JSON-LD) on every
product page, which this scraper reads directly rather than scraping
rendered text.

Here is how teams typically use this scraper:

- **Grocery price monitoring** -- track price changes and weekly offers on
  specific products or full categories over time
- **Cross-chain price comparison** -- benchmark Globus against other German
  grocery chains (Edeka, Kaufland, Rewe, Penny) or European grocers, product
  by product
- **Assortment tracking** -- see which brands and products Globus carries in
  a given category, useful for manufacturers checking retail distribution
- **Stock and availability checks** -- pull the current in-stock signal for
  products you care about
- **Weekly offer capture** -- the default run (no input) pulls the current
  weekly-offers page, which changes every week

### How to scrape Globus data

#### Search by keyword

```json
{
    "searchQuery": "kaffee",
    "maxResults": 50
}
```

Keyword search uses the storefront's autocomplete endpoint, which returns up
to about 10 matches per keyword. It's fast and precise for a specific
product, but for larger volumes use `categoryUrl` instead. Popular German
search terms: `"milch"` (milk), `"kaffee"` (coffee), `"brot"` (bread),
`"kaese"` (cheese), `"wein"` (wine), `"schokolade"` (chocolate).

#### Scrape a category page

```json
{
    "categoryUrl": "https://produkte.globus.de/obst-gemuese/",
    "maxResults": 500
}
```

Category pages paginate via `?p=N` and the scraper follows pagination
automatically until it has enough products or the category runs out. This
is the higher-volume path -- use it for anything beyond a quick keyword
check.

#### No input

Calling the actor with `{}` scrapes the current weekly-offers page
(`/angebote-der-woche/`), so you always get a populated result without
having to look up a category URL first.

#### Input reference

| Field | Type | Description |
|-------|------|--------------|
| `searchQuery` | String | German keyword to search for (default: `"milch"`) |
| `categoryUrl` | String | A produkte.globus.de category page URL to scrape |
| `maxResults` | Integer | Maximum number of products to return (default: 100, max: 50,000) |
| `proxyConfiguration` | Object | Proxy settings -- datacenter/automatic proxy works fine, no anti-bot on this storefront |

If both `searchQuery` and `categoryUrl` are set, `categoryUrl` takes
priority.

### What data does Globus Scraper extract?

Each product result includes these fields when available on the page:

- **name** -- product name/title
- **brand** -- manufacturer or brand name
- **price** -- current selling price
- **currency** -- always `EUR`
- **pricePerUnit** -- pack size and unit price, e.g. `"9,29 € / 1 kg"`
- **sku** / **ean** -- GTIN/EAN barcode (this storefront uses the GTIN as
  its internal article code, so both fields carry the same value)
- **productId** -- Shopware's internal product UUID
- **inStock** -- `true`, `false`, or `null` when the page doesn't state
  availability (never guessed)
- **category** / **categories** -- breadcrumb path, as a joined string and
  as an array
- **imageUrl** -- primary product image
- **description** -- product description text
- **language** -- always `"de"`
- **url** -- full product page URL
- **scrapedAt** -- ISO 8601 timestamp of when the item was collected

### Example output

```json
{
    "name": "Kaffee kräftig gemahlen",
    "brand": "Globus",
    "price": 4.99,
    "currency": "EUR",
    "pricePerUnit": "9,98 € / 1 kg",
    "sku": "4306188414773",
    "ean": "4306188414773",
    "productId": "0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d",
    "inStock": true,
    "category": "Brot, Backwaren & Frühstück > Kaffee > Bohnenkaffee, gemahlen",
    "categories": ["Brot, Backwaren & Frühstück", "Kaffee", "Bohnenkaffee, gemahlen"],
    "imageUrl": "https://produkte.globus.de/media/...",
    "description": "Kräftig geröstete Kaffeemischung, 500g",
    "language": "de",
    "url": "https://produkte.globus.de/brot-backwaren-fruehstueck/kaffee/bohnenkaffee-gemahlen/4306188414773/kaffee-kraeftig-gemahlen",
    "scrapedAt": "2026-09-16T14:22:10.000Z"
}
```

Export to **JSON**, **CSV**, **Excel**, **XML**, or **RSS** directly from
the Apify dataset.

### How much does it cost?

The scraper uses plain HTTP requests (CheerioCrawler, no browser) against
server-rendered pages, so per-result cost is low -- expect roughly
**$0.002-0.005 per result** on top of your Apify platform usage.

| Scenario | Products | Estimated cost |
|----------|----------|----------------|
| Quick keyword search | 20 | ~$0.02 |
| Single category | 200 | ~$0.15 |
| Multi-category export | 1,000 | ~$0.70 |
| Large catalog crawl | 5,000 | ~$3.50 |

A run's usage cost only settles once it reports **SUCCEEDED** -- checking
the cost while a run is still in progress will show a partial number, not
the final one.

### Can I integrate?

Connect Globus product data to your existing stack:

- **Webhooks** -- trigger downstream processes when a run completes
- **Google Sheets** -- auto-populate spreadsheets with product data
- **Slack / Microsoft Teams** -- alert on price drops or stock changes
- **Zapier / Make (Integromat)** -- route data to other apps without code
- **Amazon S3 / Google Cloud Storage** -- dump results to cloud buckets
- **SQL databases** -- push directly to PostgreSQL, MySQL, or BigQuery
- **REST API** -- full programmatic access (see below)

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/globus-scraper").call(run_input={
    "searchQuery": "kaffee",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} - EUR {item['price']}")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/globus-scraper").call({
    searchQuery: "kaffee",
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.name} - EUR ${item.price}`));
```

### FAQ

**Why Globus and not another German grocery chain?**
Globus is a regional hypermarket chain with a different product mix and
pricing than national discounters. If you're already tracking Edeka,
Kaufland, or Rewe, adding Globus fills in a gap those don't cover.

**Does the search field find everything in a category?**
No. `searchQuery` uses the storefront's autocomplete, which returns roughly
10 matches per keyword -- good for checking a specific product exists and
what it costs, not for a full category sweep. Use `categoryUrl` for volume.

**What if I don't know a category URL?**
Browse produkte.globus.de, apply any filters you want, and copy the
resulting URL into `categoryUrl`. The scraper follows the pagination on
that URL as-is.

**Is stock status reliable?**
`inStock` reflects what the page states (JSON-LD availability or a delivery
status indicator). When the page doesn't say either way, the field is
`null` rather than guessed as `false`.

**Is the data in German?**
Yes -- product names, descriptions, and category breadcrumbs are exactly as
published on globus.de, in German.

### Limitations

- Data is exclusively in German from produkte.globus.de
- Full-text search on the storefront itself is not available upstream, so
  `searchQuery` is limited to the ~10 autocomplete matches per keyword
- Store-specific pricing or local availability across individual Globus
  locations is not captured -- only the online catalog
- Large category crawls (thousands of products) take proportionally longer
  since each product is visited on its own detail page

### Other German grocery scrapers

Compare prices across the German grocery market with our scraper collection:

- [Edeka Scraper](https://apify.com/studio-amba/edeka-scraper)
- [Kaufland Scraper](https://apify.com/studio-amba/kaufland-de-scraper)
- [Globus Baumarkt Scraper](https://apify.com/studio-amba/globus-baumarkt-scraper) -- the unrelated DIY/hardware division
- [Mediamarkt Scraper](https://apify.com/studio-amba/mediamarkt-de-scraper)
- [Notino Germany Scraper](https://apify.com/studio-amba/notino-de-scraper)

### Maintained by Studio Amba

We run 700+ scrapers for European websites, and the priority is keeping
every one of them working. Automated runs test this actor against the live
site and verify the output is complete. When the website changes, the
scraper usually gets repaired the same day, without you having to report
anything. Questions and issues go straight to the people who built it, and
most get an answer the same day.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API, maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by keyword (e.g., 'milch', 'kaffee'). Uses the site's autocomplete endpoint, which returns up to ~10 matches. For larger volumes, use Category URL instead.

## `categoryUrl` (type: `string`):

A produkte.globus.de category page URL to scrape (e.g. https://produkte.globus.de/obst-gemuese/). Supports far more volume than Search Query.

## `maxResults` (type: `integer`):

Maximum number of products to return.

## `proxyConfiguration` (type: `object`):

Proxy settings. Datacenter/automatic proxy works fine -- no anti-bot detected on this storefront.

## Actor input object example

```json
{
  "searchQuery": "milch",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "milch",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/globus-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 = {
    "searchQuery": "milch",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/globus-scraper").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 '{
  "searchQuery": "milch",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/globus-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/globus-scraper"
        }
    }
}
```

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/d0gkiGnSdCWsDRRUW/builds/LpUJOJCu9K535WfHf/openapi.json