# 🇩🇪 Xetra Germany Stock Screener — DAX 40 Quotes (`nexgendata/xetra-germany-stock-screener`) Actor

Xetra Germany stock screener API — DAX 40 / MDAX / TecDAX live quotes, market cap (EUR), P/E, P/B, dividend yield, ROE, sector. SAP, Siemens, Allianz, Volkswagen universe. Bloomberg Terminal / FactSet / Refinitiv Eikon alternative for hedge funds, quants, fintech apps. Pay-per-result.

- **URL**: https://apify.com/nexgendata/xetra-germany-stock-screener.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $250.00 / 1,000 stocks

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/platform/actors/running/actors-in-store#pay-per-event

## 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

## 🇩🇪 Xetra Germany Stock Screener — DAX 40 Quotes & Fundamentals

Track Frankfurt Xetra and DAX 40 / MDAX constituents with prices, market cap (EUR), P/E ratio, P/B ratio, dividend yield, EPS, beta, RSI, 52-week range, sector and industry — for every German listed company that matters. A Bloomberg Terminal alternative for European institutional research, hedge fund equity desks, family offices, retail brokers and quant pipelines focused on Deutschland's USD 2 trillion equity market.

### 📊 Sample Output

[![🇩🇪 Xetra Germany Stock Screener — DAX 40 Quotes sample output — 🇩🇪 Xetra Germany Stock Screener — DAX 40 Quotes, premium API, JSON output, NexGenData premium dataset for analysts, hedge funds, complia](https://api.apify.com/v2/key-value-stores/8gLgXMBveEI1tTz1z/records/xetra-germany-stock-screener-output.png)](https://apify.com/nexgendata/xetra-germany-stock-screener)

If you cover European equities, you already know the DAX 40 is the eurozone's most-traded benchmark index and Germany is the EU's largest single-country equity allocation. This actor turns that universe into clean JSON in seconds: SAP, Siemens, Allianz, Deutsche Telekom, Mercedes-Benz, BMW, BASF, Bayer, Volkswagen, Linde, Adidas, Infineon, DHL, Munich Re, Deutsche Bank, Porsche AG, Deutsche Börse, RWE, E.ON, Continental, Henkel, Heidelberg Materials, Siemens Healthineers, Daimler Truck, Siemens Energy, Airbus, Rheinmetall, Brenntag, MTU Aero Engines, Symrise, Beiersdorf, Fresenius, Vonovia, Zalando, Sartorius, Hannover Re, Qiagen, Commerzbank, PUMA, Porsche Holding — every name you'd ever need to model, hedge, or pair-trade.

---

### What you get per stock

```json
{
  "symbol": "SAP",
  "name": "SAP SE",
  "ticker_yahoo": "SAP.DE",
  "exchange": "XETR",
  "exchange_name": "Xetra (Frankfurt)",
  "country": "Germany",
  "currency": "EUR",
  "price_eur": 147.18,
  "previous_close_eur": 151.38,
  "open_eur": 149.74,
  "pct_change": -1.43,
  "market_cap_eur": 170700000000.0,
  "market_cap_billion_eur": 170.70,
  "market_cap_display": "170.70B",
  "pe_ratio": 23.43,
  "forward_pe": 19.51,
  "pb_ratio": 5.4,
  "eps_eur": 6.24,
  "dividend_eur": 2.50,
  "dividend_yield_pct": 1.71,
  "ex_dividend_date": "May 7, 2026",
  "shares_outstanding": 1170000000,
  "net_income_eur": 7310000000,
  "volume": 2874768,
  "avg_volume": 3210000,
  "week52_low_eur": 137.54,
  "week52_high_eur": 273.55,
  "day_low_eur": 146.50,
  "day_high_eur": 148.40,
  "beta": 0.71,
  "rsi": 45.30,
  "sector": "Technology",
  "industry": "Software Application",
  "is_dax40": true,
  "is_mdax": false,
  "stockanalysis_url": "https://stockanalysis.com/quote/etr/SAP/",
  "yahoo_finance_url": "https://finance.yahoo.com/quote/SAP.DE",
  "scraped_at": "2026-05-10T07:42:00Z",
  "earnings_date": "Jul 22, 2026"
}
````

***

### Why this actor exists

The Frankfurt Stock Exchange listing on most data aggregators is a *trap*. It mashes together native German Aktiengesellschaften with thousands of foreign cross-listed ADRs that trade in EUR but represent NVIDIA, Alphabet, Realty Income, DTE Energy, AutoZone — none of which you actually want when you screen "German equities." The ticker `DTE` on the merged Frankfurt list points at DTE Energy (a US utility), even though `ETR:DTE` on Xetra is Deutsche Telekom. Same ticker, two completely different securities, multibillion-EUR market-cap delta.

This actor solves that by hitting Xetra-specific detail pages (`stockanalysis.com/quote/etr/{ticker}/`) for every DAX 40 and MDAX constituent we hardcode. That guarantees `DTE = Deutsche Telekom`, `BAYN = Bayer`, `MUV2 = Munich Re`, `VOW3 = Volkswagen` — the real Xetra securities at their real EUR-denominated prices. For `Xetra-all` mode we filter the raw Frankfurt listing by company-legal-form suffix (`AG`, `SE`, `KGaA`, `Aktiengesellschaft`, `N.V.`) to keep only native German names.

***

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `index` | enum | `DAX40` | `DAX40` (40 blue-chips), `MDAX` (50 mid-caps), `Xetra-all` (native German Xetra listings). |
| `limit` | int | `40` | Maximum stocks returned, sorted by market cap desc. |
| `min_market_cap_eur_billion` | int | `0` | Filter to caps ≥ this threshold (EUR billions). |
| `sector` | string | `""` | Case-insensitive substring filter on sector / industry / company name. |
| `enrich_fundamentals` | bool | `true` | Pull each stock's Xetra detail page for P/E, EPS, dividend, 52-week range, beta, sector. |
| `proxyConfiguration` | object | Apify default | Proxy config (datacenter by default; switch to RESIDENTIAL if rate-limited). |

#### Example inputs

DAX 40 quick scan — top 10 by market cap:

```json
{"index": "DAX40", "limit": 10}
```

All 40 DAX constituents with full fundamentals:

```json
{"index": "DAX40", "limit": 40, "enrich_fundamentals": true}
```

German banks only:

```json
{"index": "Xetra-all", "limit": 100, "sector": "bank", "enrich_fundamentals": true}
```

German mega-caps (≥ €50B market cap, automakers focus):

```json
{"index": "Xetra-all", "limit": 50, "min_market_cap_eur_billion": 50, "sector": "auto", "enrich_fundamentals": true}
```

MDAX full mid-cap pull:

```json
{"index": "MDAX", "limit": 50, "enrich_fundamentals": true}
```

Pharma/healthcare basket (Bayer, Merck, Fresenius, Sartorius, Siemens Healthineers, Qiagen, MorphoSys, Evotec):

```json
{"index": "Xetra-all", "limit": 30, "sector": "pharma", "enrich_fundamentals": true}
```

***

### Use cases

**Hedge fund equity desks** — daily snapshot of every DAX 40 + MDAX name with PE/PB/dividend yield piped straight into your factor models. No more paying €25K/seat/year for Bloomberg just to pull the DAX universe.

**European long-short funds** — pair-trade SAP vs Salesforce, Volkswagen vs Stellantis, Allianz vs AXA, Siemens vs ABB. This actor gives you the German half of every pair in clean JSON.

**Quant pipelines** — build mean-reversion, momentum or sector-rotation strategies on the DAX universe. RSI, beta, 52-week range and pct-change come pre-extracted; merge with your fundamental data lake in seconds.

**Retail brokers and roboadvisors** — populate user dashboards with live Xetra quotes plus fundamentals for every German listed name without paying for Deutsche Börse market data licensing.

**Family offices** — keep tabs on German industrials (Siemens, ThyssenKrupp, Heidelberg Materials), German pharma (Bayer, Merck KGaA, Fresenius), German autos (Mercedes-Benz, BMW, VW, Porsche), German tech (SAP, Infineon, Nemetschek) — all in one dataset.

**Equity research analysts** — pre-screen the DAX 350 by P/E, dividend yield, market cap before deep-diving into 10-Ks. Sector filter lets you carve out chemicals (BASF, Henkel, Brenntag, Symrise, K+S, Wacker, LANXESS, Evonik, Covestro) or insurance (Allianz, Munich Re, Hannover Re, Talanx) in one call.

**ETF builders / replication desks** — generate the constituent list and weights basis for your DAX/MDAX-tracking products. The `is_dax40` and `is_mdax` flags identify index membership without external lookup.

**Macro and FX research** — track Bund-sensitive financials (Deutsche Bank, Commerzbank), Energiewende names (RWE, E.ON, Siemens Energy, Encavis, SMA Solar), and export bellwethers (autos + industrials) in one run for euro-area macro pieces.

**Sustainability / ESG research** — German listed companies have some of the most aggressive sustainability mandates globally. Pull the universe and overlay your ESG scores in one batch.

***

### Pricing — Pay Per Result

- **Actor start**: $0.01 per run
- **Per stock returned**: $0.25

A full DAX 40 pull = $0.01 + (40 × $0.25) = **$10.01 per run**. A full MDAX + DAX combined ≈ $22.51. A `limit=10` smoke test ≈ $2.51. **Free tier ($5/month Apify credit) covers ~2 smoke tests or one DAX 40 snapshot per month.** Pay-as-you-go means no commitment; cancel anytime.

Compare to Bloomberg Terminal (€25,000/year) or Refinitiv Eikon (€20,000/year) just to access the same DAX universe — this actor lets you run on-demand for the price of a coffee.

***

### How it works

For `DAX40` and `MDAX` modes the actor iterates a curated, hand-verified ticker map (SAP → SAP SE, SIE → Siemens AG, etc.) and fetches each constituent's Xetra detail page on stockanalysis.com (`https://stockanalysis.com/quote/etr/{TICKER}/`). That page is server-rendered, so we parse it directly with BeautifulSoup — no Playwright, no JS execution, low latency. EUR market cap, PE, dividend yield, EPS, 52-week range, RSI, beta, sector and industry classification all come out of the same page.

For `Xetra-all` mode we walk the merged Frankfurt listing (`stockanalysis.com/list/frankfurt-stock-exchange/`) page-by-page (500 rows per page) and filter to native German listings using a legal-form regex (`\b(AG|SE|KGaA|GmbH|Aktiengesellschaft|N\.V\.)\b`) on the company name. This excludes the thousands of ADR / IOB cross-listings that contaminate the raw Frankfurt list. With `enrich_fundamentals=true` we then fetch the detail page for each surviving name to fill in PE/dividend/sector etc.

All requests go through Apify proxy by default (datacenter group, EU exit nodes). Switch to RESIDENTIAL if you hit a rate limit. Concurrency is throttled to 6 with 120ms jitter.

***

### Related actors in the NexGenData equity-screener fleet

The German market doesn't trade in a vacuum. We maintain a coordinated set of single-country / single-region equity-screener actors so you can build cross-listed pairs, ADR arb strategies, or global thematic baskets with one consistent JSON schema:

- 🇬🇧 [LSE UK Stock Screener](https://apify.com/nexgendata/lse-uk-stock-screener) — FTSE 100 / FTSE 250 / LSE main market. GBP prices, dividend yield, sector. Same schema, native UK names only.
- 🇨🇳 [Eastmoney China Stock Screener](https://apify.com/nexgendata/eastmoney-china-stock-screener) — Shanghai + Shenzhen A-shares with CNY pricing, P/E, P/B, dividend yield. Pair with German autos for China-exposure trades.
- 🇰🇷 [KOSPI Korea Stock Screener](https://apify.com/nexgendata/kospi-stock-screener) — Korea Exchange (KOSPI + KOSDAQ) with KRW pricing — Samsung, SK Hynix, LG, Hyundai.
- 🇹🇼 [TWSE Taiwan Stock Screener](https://apify.com/nexgendata/twse-stock-screener) — Taiwan Stock Exchange — TSMC, Foxconn, MediaTek, the semiconductor supply chain.

All of these share the same input pattern (`index`, `limit`, `min_market_cap_*`, `sector`, `enrich_fundamentals`) so you can wire them together in a single orchestration step.

***

### Output schema reference

Every record contains (when available):

| Field | Type | Notes |
|---|---|---|
| `symbol` | string | Xetra ticker (e.g. `SAP`, `BAYN`, `MUV2`). |
| `name` | string | Full legal name. |
| `ticker_yahoo` | string | Yahoo Finance ticker (suffix `.DE`). |
| `exchange` | string | Always `XETR`. |
| `currency` | string | Always `EUR`. |
| `price_eur` | float | Latest available price. |
| `previous_close_eur` | float | Prior session close. |
| `open_eur` | float | Today's open. |
| `pct_change` | float | Day-on-day % move. |
| `market_cap_eur` | float | EUR market cap (absolute). |
| `market_cap_billion_eur` | float | EUR market cap in billions. |
| `pe_ratio` | float | Trailing P/E. |
| `forward_pe` | float | Forward P/E. |
| `pb_ratio` | float | Price-to-book. |
| `eps_eur` | float | EPS. |
| `dividend_eur` | float | Annual dividend per share. |
| `dividend_yield_pct` | float | Dividend yield %. |
| `shares_outstanding` | float | Shares outstanding (absolute). |
| `net_income_eur` | float | TTM net income. |
| `volume` | float | Today's share volume. |
| `week52_low_eur` / `week52_high_eur` | float | 52-week range. |
| `beta` | float | 5y beta vs DAX. |
| `rsi` | float | 14-day RSI. |
| `sector` | string | GICS-style sector. |
| `industry` | string | GICS-style industry. |
| `is_dax40` / `is_mdax` | bool | Index membership flags. |

***

### Disclaimer

Data is sourced from public, web-rendered pages on stockanalysis.com (Frankfurt and Xetra detail). It is delayed quote data, not exchange-real-time, and is intended for research, screening and back-testing — NOT for live trade execution. For real-time Deutsche Börse data with millisecond latency, license the official Xetra market-data feed.

***

### Get started

Run the actor with `{"index": "DAX40", "limit": 10}` for a 10-stock smoke test. Pull the full DAX 40 with `{"index": "DAX40", "limit": 40}`. Combine DAX 40 + MDAX with two runs and a JSON merge.

**Want the full NexGenData fleet?** We run 100+ private and public actors for institutional equity research, alternative data, scraping infrastructure, and Bloomberg-alternative pricing. Browse the catalog and try a few — start with the free Apify tier ($5/month credit).

👉 **[Browse all NexGenData actors on Apify](https://apify.com/nexgendata?fpr=2ayu9b)**

***

### Explore the NexGenData Equity Data Suite

This actor is part of NexGenData's global equity data fleet. Whether you cover a single region or a multi-asset macro book, we have a screener for every major market:

#### Regional sisters

- 🔗 **[LSE UK Stock Screener](https://apify.com/nexgendata/lse-uk-stock-screener)** — London Stock Exchange (FTSE 100 / 250) fundamentals, market cap (GBP), P/E, dividend yield, sector — UK equity data.
- 🔗 **[Finviz Stock Screener (US)](https://apify.com/nexgendata/finviz-stock-screener)** — US equities (NYSE / NASDAQ / AMEX) with 70+ filters — market cap, P/E, sector, technicals, insider activity.
- 🔗 **[TSE Japan Stock Screener](https://apify.com/nexgendata/tse-japan-stock-screener)** — Tokyo Stock Exchange (Nikkei 225 / TOPIX) fundamentals, market cap (JPY), P/E, P/B, dividend yield, sector.

#### Cross-region peers

- 🔗 **[ASX Australia Stock Screener](https://apify.com/nexgendata/asx-australia-stock-screener)** — ASX 200 / All Ordinaries fundamentals, market cap (AUD), P/E, dividend yield, sector — Australian equity data.
- 🔗 **[TSX Canada Stock Screener](https://apify.com/nexgendata/tsx-canada-stock-screener)** — Toronto Stock Exchange (TSX 60 / Composite) fundamentals, market cap (CAD), P/E, dividend yield, sector.

#### Multi-asset / specialty

- 🔗 **[Finance MCP Server](https://apify.com/nexgendata/finance-mcp-server)** — Unified Model Context Protocol server exposing the full NexGenData equity fleet to Claude, Cursor & MCP-aware LLMs.

#### Browse the full NexGenData catalog

**[→ See all 220+ NexGenData actors at apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b)** — equity screeners across 25+ markets, lead generation, SEC filings, B2B intelligence, MCP servers, and more.

***

### Why NexGenData vs. paid alternatives

| Tool | Annual cost | API access | Coverage |
|------|-------------|------------|----------|
| Bloomberg Terminal | ~$24,000/seat | Limited | Global |
| FactSet | ~$15,000/seat | Paid add-on | Global |
| Refinitiv Eikon | ~$22,000/seat | Paid add-on | Global |
| S\&P Capital IQ | ~$20,000/seat | Paid add-on | Global |
| **NexGenData Germany Screener** | **Pay-per-result** | **Native** | **Germany**          |

Run this actor once per day for a typical institutional-scale workflow (~200 records/day) and your annual cost is approximately **$1,800–2,000** — a 90-95% discount vs. the major paid alternatives, with no seat licensing, no minimum commitment, and full programmatic access.

# Actor input Schema

## `index` (type: `string`):

Which German market scope to screen: DAX40 (DAX 40 blue-chip constituents only — Germany's premier index, e.g. SAP, Siemens SIE, Allianz ALV, Deutsche Telekom DTE, Mercedes-Benz MBG, BMW, Adidas ADS, Linde LIN), MDAX (MDAX mid-cap constituents — 50 names just below DAX), or Xetra-all (entire Frankfurt / Xetra native German main-market listings — excludes foreign ADRs and cross-listings).

## `limit` (type: `integer`):

Maximum number of German stocks to return. Stocks are returned in descending market-cap order. Use 10 for a quick smoke test, 40 for the full DAX 40, 50 for full MDAX, 90+ for combined DAX 40 + MDAX coverage, 200+ for broader Xetra-all.

## `min_market_cap_eur_billion` (type: `integer`):

Filter to stocks with market cap above this threshold, in BILLIONS of EUR. Examples: 10 = €10B (roughly large-cap, DAX 40 floor is around €10-15B), 50 = €50B (mega-cap like SAP, Siemens, Allianz, Linde, Deutsche Telekom), 100 = €100B (top 5 German companies). Leave at 0 for no filter.

## `sector` (type: `string`):

Optional case-insensitive substring filter applied to sector, industry, and company name. Examples: 'auto' (BMW, Mercedes-Benz, Volkswagen, Porsche, Daimler Truck, Continental), 'bank' (Deutsche Bank, Commerzbank), 'pharma' (Bayer, Merck KGaA, Fresenius), 'chemi' (BASF, Henkel, Brenntag), 'insurance' (Allianz, Munich Re, Hannover Rück), 'tech' (SAP, Infineon), 'energy' (RWE, E.ON, Siemens Energy). Leave blank for no filter. Note: sector matching requires enrich\_fundamentals=true.

## `enrich_fundamentals` (type: `boolean`):

If true, fetch each stock's Xetra detail page on stockanalysis.com to extract P/E ratio, EPS, dividend yield, shares outstanding, beta, RSI, 52-week range, sector and industry classification. Adds ~1 HTTP request per stock and roughly doubles runtime. Required if you want to filter by sector. Recommended ON for DAX40 (only 40 stocks) and MDAX (50 stocks) modes.

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

Apify proxy configuration. Defaults to Apify datacenter proxy for reliable access to stockanalysis.com. Use RESIDENTIAL group if you hit rate limits.

## Actor input object example

```json
{
  "index": "DAX40",
  "limit": 40,
  "min_market_cap_eur_billion": 0,
  "enrich_fundamentals": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "index": "DAX40",
    "limit": 40,
    "min_market_cap_eur_billion": 0,
    "sector": "",
    "enrich_fundamentals": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/xetra-germany-stock-screener").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 = {
    "index": "DAX40",
    "limit": 40,
    "min_market_cap_eur_billion": 0,
    "sector": "",
    "enrich_fundamentals": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/xetra-germany-stock-screener").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 '{
  "index": "DAX40",
  "limit": 40,
  "min_market_cap_eur_billion": 0,
  "sector": "",
  "enrich_fundamentals": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nexgendata/xetra-germany-stock-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/xetra-germany-stock-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🇩🇪 Xetra Germany Stock Screener — DAX 40 Quotes",
        "description": "Xetra Germany stock screener API — DAX 40 / MDAX / TecDAX live quotes, market cap (EUR), P/E, P/B, dividend yield, ROE, sector. SAP, Siemens, Allianz, Volkswagen universe. Bloomberg Terminal / FactSet / Refinitiv Eikon alternative for hedge funds, quants, fintech apps. Pay-per-result.",
        "version": "0.0",
        "x-build-id": "crNRUCuL84eMemfFv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~xetra-germany-stock-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-xetra-germany-stock-screener",
                "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/nexgendata~xetra-germany-stock-screener/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-xetra-germany-stock-screener",
                "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/nexgendata~xetra-germany-stock-screener/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-xetra-germany-stock-screener",
                "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",
                "properties": {
                    "index": {
                        "title": "Index / Market",
                        "enum": [
                            "DAX40",
                            "MDAX",
                            "Xetra-all"
                        ],
                        "type": "string",
                        "description": "Which German market scope to screen: DAX40 (DAX 40 blue-chip constituents only — Germany's premier index, e.g. SAP, Siemens SIE, Allianz ALV, Deutsche Telekom DTE, Mercedes-Benz MBG, BMW, Adidas ADS, Linde LIN), MDAX (MDAX mid-cap constituents — 50 names just below DAX), or Xetra-all (entire Frankfurt / Xetra native German main-market listings — excludes foreign ADRs and cross-listings).",
                        "default": "DAX40"
                    },
                    "limit": {
                        "title": "Limit (stocks returned)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of German stocks to return. Stocks are returned in descending market-cap order. Use 10 for a quick smoke test, 40 for the full DAX 40, 50 for full MDAX, 90+ for combined DAX 40 + MDAX coverage, 200+ for broader Xetra-all.",
                        "default": 40
                    },
                    "min_market_cap_eur_billion": {
                        "title": "Min market cap (billion EUR)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Filter to stocks with market cap above this threshold, in BILLIONS of EUR. Examples: 10 = €10B (roughly large-cap, DAX 40 floor is around €10-15B), 50 = €50B (mega-cap like SAP, Siemens, Allianz, Linde, Deutsche Telekom), 100 = €100B (top 5 German companies). Leave at 0 for no filter.",
                        "default": 0
                    },
                    "sector": {
                        "title": "Sector / industry / name keyword",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter applied to sector, industry, and company name. Examples: 'auto' (BMW, Mercedes-Benz, Volkswagen, Porsche, Daimler Truck, Continental), 'bank' (Deutsche Bank, Commerzbank), 'pharma' (Bayer, Merck KGaA, Fresenius), 'chemi' (BASF, Henkel, Brenntag), 'insurance' (Allianz, Munich Re, Hannover Rück), 'tech' (SAP, Infineon), 'energy' (RWE, E.ON, Siemens Energy). Leave blank for no filter. Note: sector matching requires enrich_fundamentals=true."
                    },
                    "enrich_fundamentals": {
                        "title": "Enrich with fundamentals (slower)",
                        "type": "boolean",
                        "description": "If true, fetch each stock's Xetra detail page on stockanalysis.com to extract P/E ratio, EPS, dividend yield, shares outstanding, beta, RSI, 52-week range, sector and industry classification. Adds ~1 HTTP request per stock and roughly doubles runtime. Required if you want to filter by sector. Recommended ON for DAX40 (only 40 stocks) and MDAX (50 stocks) modes.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Defaults to Apify datacenter proxy for reliable access to stockanalysis.com. Use RESIDENTIAL group if you hit rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
