# Germany Property Listings API - Rent, Buy, Commercial (`nabeelbaghoor/germany-property-listings-api`) Actor

Search live German and Austrian property listings by region or radius across twenty types, from apartments and houses to offices, retail, plots and auctions, with filters on price, space, rooms, year and equipment. Plus full listings with photos, place lookup, region counts and mortgage rates.

- **URL**: https://apify.com/nabeelbaghoor/germany-property-listings-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Real estate, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 property listing returneds

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Germany Property Listings API - Rent, Buy, Commercial

Pull the German and Austrian listings market into a table: what is on the market, where, at what price, and how many of it a region holds.

### What it collects

- **Listings by region**: search a region code across twenty real estate types, from apartments and houses to flat share rooms, offices, retail stores, gastronomy, industrial space, investment properties, plots and compulsory auctions.
- **Listings by radius**: the same search around a latitude and longitude with a radius in kilometres.
- **One listing in full**: the provider assembles the property, its address, its attributes, its contact and its attachments into a single record, so a full listing is one call rather than four.
- **Photos, floor plans and videos**: every attachment on a listing with its type, title, publication date and file link.
- **Places**: resolve a town, district, postcode, street or station name to the provider's own region code and coordinates, and walk the hierarchy from continent down to quarter. This is how a place name becomes the code the region search needs.
- **Region counts**: how many listings a region and its direct subregions hold, broken down by real estate type.
- **Mortgage rates**: the average nominal and effective interest rates for a region, given a purchase price, own funds, repayment rate, fixed interest period, employment and lender kind.

### FAQ

#### What is a German property listings API used for?

Watching a market rather than browsing it. A portal or a CRM syncs listings into its own product. An analyst tracks asking prices and time on market across districts. A relocation or mortgage service prices a search area before quoting. A valuation model needs live comparables in the same postcode. All of those want the same thing: a repeatable query that returns the market as rows, which is what this actor is.

#### How do I search a particular area?

By region code or by radius. A region code is the provider's own geocode id, built from continent, country, region, city and quarter ids run together, such as `1276003001014`. Run the place lookup service on a name first to get the code, then feed it to the region search. If you already have coordinates, the radius search takes `latitude;longitude;radius` with the radius in kilometres and skips the lookup entirely. Radius search does not reach properties outside Germany and Austria.

#### Why does the actor refuse to send some of my filters?

Because this API accepts a different filter set for each real estate type, and its own documentation warns that an unknown search criterion is "ignored or results in an empty result list". The second half of that is the trap: a filter that belongs to another type does not produce an error, it can produce zero hits that look exactly like a market with nothing in it. So the actor keeps each type's documented filters and leaves the rest off the request, and says in the log which ones it dropped and why.

#### What does an empty price mean?

Price on application, and the row says so. The provider states that it always sends the marketing type, that a missing price means the price is on request, and that on the commercial types and plots a returned price of zero means the same thing. Both cases set `priceOnRequest` to true rather than leaving an empty column, because "the seller will not say" is a fact about the offer and must not look like a gap in the data.

#### Can this actor publish a listing or spend money?

No. The provider publishes routes that insert and publish a property, upload attachments, buy on-top placements, create contact requests and book financing appointments, and none of them is wired up anywhere in this actor. Every route it can reach is a read. That is a deliberate limit, because a scheduled run that could put a property on the market is a scheduled run that eventually will.

#### What credentials do I need, and do I need all of them?

Usually two of the four. This API signs every request with OAuth 1.0a rather than taking a bearer token. Two-legged signing uses your consumer key and consumer secret alone, and that covers the searches, the place services, the region counts and the mortgage rates. Three-legged signing adds an access token and its secret, and is only needed to reach one particular customer's own data, such as their listings on their own homepage channel. The actor runs two-legged when you leave the token blank, and says so in the log.

#### Why did it say my key was refused without saying what was wrong?

Because the provider does not say either: a refusal is an empty HTTP 401 with no body and no `WWW-Authenticate` header. Four things produce it, and the actor names all four rather than guessing one: the consumer key or secret is wrong, the machine's clock is too far out for the signed timestamp to verify, the service you chose needs the three-legged access token you left blank, or your account has not been granted permission for that resource. The main portal channel in particular needs a content partner permission on your account.

#### How do I read only what is new since the last run?

With the first activation filter, which takes a date and time and returns only listings first published after it. The separate published-after field looks similar and does something different: it does not filter at all, it adds a flag to each listing saying whether it was published after that moment. Reaching for the wrong one is how people end up re-reading the whole market every night.

#### How does paging work?

The search returns the total page count, and the actor walks pages until it reaches it rather than stopping at the first short page, because a page can legitimately come back short of the size you asked for. Page size is yours to set between 1 and 200, and a larger page means fewer requests for the same results. The maximum results input is what bounds the whole run.

#### Why is the provider's record kept whole instead of split into columns?

Because twenty real estate types answer in twenty shapes, and a fixed set of columns would silently drop most of what you asked for. The columns that are lifted are the ones the provider documents on every entry: the id, the link, the creation and modification timestamps, and the price question above. Everything else sits under `record`, unchanged, including the whole address and attribute block for that type.

#### What does it cost?

Pay per result. A listing row costs the most, because it carries the whole property record. A place row costs a little less, an attachment row less again because one listing commonly carries a dozen, and region counts and rate readings are priced near zero, since the readings you take before deciding what to spend on should not themselves cost much. Platform usage is included, and a search that matches nothing is never charged.

### Example output

```json
{
  "service": "searchRegion",
  "serviceLabel": "Search listings in a region",
  "realEstateType": "apartmentRent",
  "requested": "1276003001014",
  "found": true,
  "recordType": "listing",
  "id": "123456",
  "listingUrl": "https://rest.immobilienscout24.de/restapi/api/search/v1.0/expose/123456",
  "created": "2026-05-16T20:26:56.000+02:00",
  "modified": "2026-05-17T20:53:24.000+02:00",
  "price": 1450,
  "currency": "EUR",
  "priceOnRequest": false,
  "page": 1,
  "totalHits": 87,
  "record": { "...": "every field the provider published, unchanged" },
  "note": null
}
```

### Keyword map

Germany property API, German real estate API, property listings API Germany, Austria property listings API, apartment rent data Germany, house prices Germany API, commercial real estate API Germany, office listings API, retail property data, German property market data, real estate search API, geocode lookup Germany, postcode lookup Germany, German property portal API, OAuth 1.0a real estate API, Immobilien API, Mietwohnung data feed, property attachments API, floor plan data, mortgage interest rates Germany API, Baufinanzierung rates API, listings by region code, radius property search, compulsory auction listings Germany.

# Actor input Schema

## `service` (type: `string`):

One service per run. The two searches return listings, by a radius around a point or by a region code. The listing services read one property in full and the photos, floor plans and videos on it. The place services resolve a name to a region code or coordinates and let you walk the hierarchy from continent down to quarter. The statistics service counts what a region holds, and the financing service returns average mortgage rates.

## `realEstateType` (type: `string`):

Which kind of property the search looks for. This choice also decides which filters the provider accepts, so a filter that belongs to another type is left off the request rather than sent: this API can answer an unknown criterion with an empty result list rather than an error.

## `geoCodes` (type: `array`):

One region code per line, for the region search and the statistics service. A code is the provider's own geocode id, built from continent, country, region, city and quarter ids run together, for example 1276003001014. Use the place lookup service to find the code for a name.

## `geoCoordinates` (type: `array`):

One area per line for the radius search, written as latitude;longitude;radius with the radius in kilometres, for example 52.512303;13.431191;1. Latitude comes first, which is how people write coordinates, and a line written with commas is accepted and rewritten. Radius search does not reach properties outside Germany and Austria.

## `exposeIds` (type: `array`):

One listing id per line, for the full listing and attachment services. Run a search first to collect them.

## `geoQueries` (type: `array`):

One term per line for the place lookup: a town, a district, a postcode, a street or a station name. Each becomes its own lookup.

## `geoEntityIds` (type: `array`):

One place id per line, as the place lookup returns them. This resolves an id to its type, label, address and, when you ask for it, its region code or coordinates.

## `geoCountry` (type: `string`):

Which country's places to search. The provider covers Germany and Austria for the place lookup.

## `geoEntityTypes` (type: `array`):

Which kinds of place the lookup should consider. Leave empty and the provider uses its own default set. Postcode with quarter is rarely what you want: it combines a postcode with a district in a way real addresses usually do not.

## `geoSuggestionLimit` (type: `integer`):

How many suggestions one lookup should return. The provider caps this at 120 and uses 50 when it is left blank.

## `geoCoding` (type: `string`):

Whether the single place service should add the region code or the coordinates of the place's centre to its basic details.

## `geoHierarchyIds` (type: `array`):

One level id per line, from continent downwards: continent, country, region, city, quarter. The depth is the request. Leave it empty to list the continents, give one id to list that continent's countries, two to list a country's regions, and so on. Five ids name one quarter outright.

## `statisticRealEstateTypes` (type: `array`):

Which real estate types the statistics service should count in the region. Leave empty to count all of them.

## `priceMin` (type: `number`):

Lowest price to accept. What the price means depends on the type and on the price basis below: a monthly rent, a purchase price, a rent per square metre, or a lease.

## `priceMax` (type: `number`):

Highest price to accept. Either bound can be left blank, which the provider reads as no limit on that side.

## `priceType` (type: `string`):

What the price range refers to, for the types that offer a choice. Rent per month and budget rent apply to residential rentals, where budget rent is the provider's combined figure across every cost on the offer. Rent per square metre, buy, lease and long lease apply to the commercial types and plots. Left blank, no price basis is filtered on.

## `livingSpaceMin` (type: `number`):

Smallest living space to accept. Accepted by the apartment, house and flat share types.

## `livingSpaceMax` (type: `number`):

Largest living space to accept.

## `roomsMin` (type: `number`):

Fewest rooms to accept. Accepted by the apartment, house and short term accommodation types.

## `roomsMax` (type: `number`):

Most rooms to accept.

## `constructionYearMin` (type: `integer`):

Earliest construction year to accept. Accepted by the apartment and house types.

## `constructionYearMax` (type: `integer`):

Latest construction year to accept.

## `groundMin` (type: `number`):

Smallest plot to accept, for houses to buy or rent.

## `groundMax` (type: `number`):

Largest plot to accept, for houses to buy or rent.

## `plotAreaMin` (type: `number`):

Smallest site to accept, for the residential and commercial plot types.

## `plotAreaMax` (type: `number`):

Largest site to accept, for the plot types.

## `totalFloorSpaceMin` (type: `number`):

Smallest total floor space to accept. Accepted by the gastronomy, industrial, special purpose and store types.

## `totalFloorSpaceMax` (type: `number`):

Largest total floor space to accept.

## `netFloorSpaceMin` (type: `number`):

Smallest net floor space to accept. Accepted by the industrial, investment, office and store types.

## `netFloorSpaceMax` (type: `number`):

Largest net floor space to accept.

## `marketValueMin` (type: `number`):

Lowest market value to accept, for compulsory auction listings.

## `marketValueMax` (type: `number`):

Highest market value to accept, for compulsory auction listings.

## `parkingSpacesMin` (type: `integer`):

Fewest parking spaces to accept, for office listings.

## `parkingSpacesMax` (type: `integer`):

Most parking spaces to accept, for office listings.

## `bedsMin` (type: `integer`):

Fewest beds to accept, for gastronomy listings.

## `bedsMax` (type: `integer`):

Most beds to accept, for gastronomy listings.

## `seatsMin` (type: `integer`):

Fewest seats to accept, for gastronomy listings.

## `seatsMax` (type: `integer`):

Most seats to accept, for gastronomy listings.

## `pricePerSqmMin` (type: `number`):

Lowest price per square metre to accept, for investment listings.

## `pricePerSqmMax` (type: `number`):

Highest price per square metre to accept, for investment listings.

## `priceMultiplierMin` (type: `number`):

Lowest price multiplier to accept, for investment listings. The provider calculates it as the price divided by the annual net cold rent.

## `priceMultiplierMax` (type: `number`):

Highest price multiplier to accept, for investment listings.

## `equipment` (type: `array`):

Features the property must have. Which of these a type accepts differs: the residential types document built-in kitchen, parking, balcony, garden, lift, guest toilet, cellar, wheelchair access, assisted living and lodger flat; the commercial types document high voltage, air conditioning, network cabling, goods lift, car lift, crane runway and ramp. One line per feature, spelled as the provider spells it.

## `apartmentTypes` (type: `array`):

Which apartment kinds to accept, for the apartment types. The provider documents apartment, groundfloor, halfbasement, loft, maisonette, other, penthouse, raisedgroundfloor, roofstorey and terracedflat.

## `buildingTypes` (type: `array`):

Which building kinds to accept, for the house types. The provider documents singlefamilyhouse, midterracehouse, endterracehouse, multifamilyhouse, bungalow, farmhouse, semidetachedhouse, villa, castlemanorhouse, specialrealestate and otherrealestate.

## `heatingTypes` (type: `array`):

Which heating kinds to accept, for the apartment and house types. The provider documents stove, selfcontainedcentral and central.

## `constructionPhaseTypes` (type: `array`):

Which construction phases to accept, for houses to buy. The provider documents projected, underconstruction, completed and noinformation.

## `officeTypes` (type: `array`):

Which office kinds to accept. The provider documents loft, studio, office, officefloor, officebuilding, officecentre, officestoragebuilding, surgery, surgeryfloor, surgerybuilding, commercialcentre, livingandcommercialbuilding and officeandcommercialbuilding.

## `garageTypes` (type: `array`):

Which garage kinds to accept. The provider documents garage and streetparking.

## `gastronomyTypes` (type: `array`):

Which gastronomy kinds to accept. The provider documents guestshouse, clubdisco, barlounge, cafe, hotelresidence, tavern, hotelgarni, hotel, restaurant, pension and bungalow.

## `industryTypes` (type: `array`):

Which industrial kinds to accept. The provider documents showroomspace, hall, highlackstorage, industryhall, industryhallwithopenarea, coldstorage, multideckcabinetstorage, storagewithopenarea, storagearea, storagehall, servicearea, shippingstorage and repairshop.

## `investmentTypes` (type: `array`):

Which investment kinds to accept. The provider documents singlefamilyhouse, multifamilyhouse, freeholdflat, shoppingcentre, restaurant, hotel, leisurefacility, commercialunit, officebuilding, commercialbuilding, commercialproperty, hallstorage, industrialproperty, shopsalesfloor, servicecentre, other, supermarket, livingbusinesshouse and housingestate.

## `storeTypes` (type: `array`):

Which retail kinds to accept. The provider documents showroomspace, shoppingcentre, factoryoutlet, departmentstore, kiosk, store, selfservicemarket, salesarea and saleshall.

## `specialPurposeTypes` (type: `array`):

Which special purpose kinds to accept. The provider documents residence, farm, horsefarm, vineyard, repairshop, leisurefacility, industrialarea, specialestate and commercialcentre.

## `siteConstructibleTypes` (type: `array`):

Which constructibility categories to accept, for the residential plot types. The provider documents externalarea, constructionplan and neighbourconstruction.

## `siteDevelopmentTypes` (type: `array`):

Which development states to accept, for the residential plot types. The provider documents developed, developedpartially and notdeveloped.

## `utilizationTradeSites` (type: `array`):

Which intended uses to accept, for commercial plots. The provider documents leisure, agricultureforestry and trade.

## `auctionObjectTypes` (type: `array`):

Which auction object kinds to accept. The provider documents freeholdflat, familyhouse, businessandyield, lot and garageandother.

## `auctionTypes` (type: `array`):

Which auction kinds to accept. The provider documents recurrenceappointment and splittingauction.

## `rentDuration` (type: `array`):

Which rental terms to accept, for office listings. The provider documents weekly, monthly, yearly and longterm.

## `rented` (type: `string`):

For apartments and houses to buy, whether the property comes with a sitting tenant. Left blank, both are returned.

## `newBuilding` (type: `boolean`):

Only buildings put up in the last three years, as the provider defines a new build.

## `buildingProject` (type: `boolean`):

Only properties that belong to a larger development project.

## `freeOfCourtageOnly` (type: `boolean`):

Only listings that carry no buyer or tenant commission.

## `shortTermConstructible` (type: `boolean`):

Only plots that can be built on in the short term.

## `buildingPermission` (type: `boolean`):

Only plots that already hold a building permission.

## `flatShareSize` (type: `string`):

How many people share the flat, for flat share rooms. The provider takes 2 to 10 or greaterthenten.

## `gender` (type: `string`):

Which gender the flat share is looking for, where the advertiser states one.

## `furniture` (type: `string`):

Whether the room or short term accommodation comes furnished.

## `smokingAllowed` (type: `string`):

The smoking rule in a flat share, as the advertiser sets it.

## `startRentalDate` (type: `string`):

Earliest move-in date, as an ISO date such as 2026-11-01. Accepted by flat share rooms and short term accommodation.

## `rentalDuration` (type: `string`):

How many months the rental should run, for flat share rooms. The provider takes 1 to 100.

## `shortTermAccommodationType` (type: `string`):

Which kind of short term accommodation to accept.

## `locationClassification` (type: `string`):

Which retail location class to accept, for stores. The provider documents a, b and shoppingcentre.

## `fullText` (type: `string`):

Free text matched across the whole listing, its description and its attributes. Several terms are combined as alternatives rather than as requirements, so more terms widen the search rather than narrowing it.

## `publishedAfter` (type: `string`):

A date and time such as 2026-06-01T00:00:00. This does not filter anything: it adds a flag to each listing saying whether it was published after that moment. Use the first activation field below to actually filter.

## `firstActivation` (type: `string`):

A date and time such as 2026-06-01T00:00:00. This one does filter: only listings first published after that moment come back, which is how you read just what is new since your last run.

## `channel` (type: `string`):

Which publication channel to read. The provider's main portal needs a content partner permission on your account; a customer's own homepage needs their username and their three-legged authorisation; a group id reads the listings of everyone in that group.

## `username` (type: `string`):

Whose listings to read, for the homepage channel. Use "me" when the access token below belongs to that customer.

## `features` (type: `array`):

Extras the provider can add to a search response. Grouping collects listings from the same vendor under the main hit, for office listings. Match count returns how many listings match each individual search criterion.

## `sorting` (type: `string`):

Which field to sort listings by, as the provider names it. Apartments and houses accept price, livingspace and rooms; apartments to rent also accept budgetrent; auctions accept marketvalue. Prefix with a minus for descending, for example -price. Left blank, the provider sorts by placement and then by activation date.

## `pageSize` (type: `integer`):

How many listings the provider returns per page. It accepts 1 to 200 and uses 20 when this is left blank. A larger page means fewer requests for the same results.

## `purchasePrice` (type: `number`):

The purchase price of the project, for the mortgage rates service.

## `ownFunds` (type: `number`):

How much the buyer puts in themselves, for the mortgage rates service.

## `amortizationRate` (type: `number`):

The repayment rate to price against, for the mortgage rates service.

## `fixedNominalInterestRate` (type: `string`):

How long the nominal interest rate is fixed for, for the mortgage rates service.

## `employment` (type: `string`):

The buyer's employment situation, for the mortgage rates service. Lenders price these differently, so it changes the average.

## `providerType` (type: `string`):

Which kind of lender to average over, for the mortgage rates service.

## `financingGeoCode` (type: `string`):

Which region to average the rates over, as a region code. The provider uses 1276, all of Germany, when this is left blank.

## `extraParameters` (type: `object`):

Any other parameter the provider documents for the selected service that this actor does not have its own field for. Given as a JSON object, for example {"apisearchfield1": "run7"}. Nothing here is invented: it is passed to the provider exactly as written, so check the name against the provider's own documentation first.

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

Stop after this many rows. A region search can run to thousands of listings across many pages, so this is what bounds a run.

## `requestsPerMinute` (type: `integer`):

Pacing ceiling. The provider's standard limit is 2000 requests per minute per key and it refills continuously, so the default here leaves plenty of room for anything else using the same key.

## `consumerKey` (type: `string`):

Your own consumer key from your provider account. This actor is bring-your-own-key and never ships credentials of its own.

## `consumerSecret` (type: `string`):

Your own consumer secret, which signs every request. Leave both this and the consumer key blank to use the DATA\_API\_KEY environment secret instead, written as consumer key and consumer secret separated by a colon, with the access token and its secret appended in the same way when you have them.

## `accessToken` (type: `string`):

Optional. Only needed to reach one customer's own data, such as their listings on their own homepage channel. The search, the place services, the region statistics and the mortgage rates all work without it.

## `accessTokenSecret` (type: `string`):

Optional, and required whenever the access token is set. It is the second half of the signing key for a three-legged call.

## `baseUrl` (type: `string`):

Override the host the actor calls. Set this to the provider's sandbox host to test against it.

## Actor input object example

```json
{
  "service": "searchRegion",
  "realEstateType": "apartmentRent",
  "geoCountry": "DEU",
  "newBuilding": false,
  "buildingProject": false,
  "freeOfCourtageOnly": false,
  "shortTermConstructible": false,
  "buildingPermission": false,
  "maxResults": 500,
  "requestsPerMinute": 120
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record, alongside the region, point or id that produced it.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/germany-property-listings-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/germany-property-listings-api").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 '{}' |
apify call nabeelbaghoor/germany-property-listings-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/germany-property-listings-api"
        }
    }
}
```

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/gcoUK30XEVJQyejnZ/builds/LrifzFzpHRrKEbHr0/openapi.json