# LinkedIn Jobs by Location (`apixyz/linkedin-jobs-by-location`) Actor

Compare one LinkedIn guest job search across up to 20 locations. Export structured job cards labeled by the requested market. No login or cookies.

- **URL**: https://apify.com/apixyz/linkedin-jobs-by-location.md
- **Developed by:** [Tarek Etman](https://apify.com/apixyz) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Compare the same LinkedIn job search across up to 20 cities, regions, or countries in one run. Each row keeps the requested search location, so teams can group jobs by market without managing separate exports. No LinkedIn account, cookies, or proxy setup is required.

The current Store configuration charges $0.005 at run start and $0.002 per accepted job row. Apify platform usage is billed separately to the user.

### A location matrix for hiring demand

This Actor is designed for a repeated location question: where is a specific role currently being advertised? Workforce planners can compare target hiring markets with one consistent keyword. Staffing teams can build regional sourcing queues that retain the exact city, region, or country used for each search.

Each location is paginated and reported separately. A source failure for one location allows later locations to be attempted. Global item, page, and billing limits stop remaining work, and `OUTPUT_SUMMARY` identifies skipped locations.

### Sample output

```json
{
  "jobId": "4001000002",
  "title": "DevOps Engineer",
  "company": "Berlin Tech GmbH",
  "location": "Berlin, Germany",
  "salary": "€70,000/yr - €90,000/yr",
  "postedAt": "2026-07-19",
  "postedText": "1 day ago",
  "url": "https://www.linkedin.com/jobs/view/4001000002/",
  "searchKeywords": "DevOps engineer",
  "searchLocation": "Berlin, Germany",
  "scrapedAt": "2026-07-20T09:00:00.000Z"
}
````

`location` is the text shown on the posting. `searchLocation` is the market requested in the input. A remote role or regional posting can make those values different, which is useful when the output is grouped later.

### Input

Add one to 20 entries in `locations`, using the place names you would enter in LinkedIn search. The optional `keywords` value is applied to each location.

```json
{
  "locations": [
    "Berlin, Germany",
    "Munich, Germany",
    "Hamburg, Germany",
    "Frankfurt, Germany"
  ],
  "keywords": "DevOps engineer",
  "maxItemsPerLocation": 100,
  "maxTotalItems": 1000,
  "maxTotalPages": 120
}
```

`maxItemsPerLocation` is a safety cap, up to 1,000 jobs. Reaching it marks that location incomplete in `OUTPUT_SUMMARY`. The full run is bounded to 10,000 returned rows and 400 result-page requests.

Output stays at the job-card level. For supported filters, bulk keyword-location combinations, and bounded public detail enrichment, use `linkedin-jobs-scraper`.

### Output and export

Rows contain job ID, title, company, posting location, salary when shown, posting date, URL, requested location, keyword, and fetch time. Export the dataset as JSON, CSV, Excel, or XML, or retrieve it through the Apify dataset API.

The summary records counts and stop reasons for each location, skipped locations, total budgets, and overall completeness. A source block, parser failure, transport failure, configured cap, or billing limit is reported as an incomplete result.

### Pricing

The current public configuration uses a $0.005 Actor-start event and a $0.002 `job-collected` event. A run returning 800 accepted rows creates $1.605 in Actor event charges. Apify platform usage, including compute and data transfer where applicable, is charged separately under the user's Apify plan.

An empty location has no per-job event. The start event and any platform usage can still apply.

### Choosing the right LinkedIn Jobs Actor

Use this Actor when one keyword must be compared across named markets with a separate result group for each. Use `linkedin-jobs-scraper` when the work needs supported filters, different keywords per query, optional company or geo IDs, or available public detail fields.

### Common questions

**Can one run mix countries and cities?** Yes. Each location is processed as its own search segment.

**Why does a location show zero jobs?** Check its stop reason in `OUTPUT_SUMMARY`. A genuine empty final page is distinguished from a blocked or unparsable response.

**Does salary appear on each row?** Salary is null when LinkedIn omits it from the public card.

**How do I know the comparison is complete?** Confirm the run-level `complete` value and review each location entry before using the counts in a market comparison.

### Support

Include the Apify run ID, input locations, keyword, and `OUTPUT_SUMMARY` when reporting a reproducible issue. Remove private labels or downstream customer data first.

# Actor input Schema

## `locations` (type: `array`):

Add one to 20 cities, regions, or countries. Each location is searched and reported separately.

## `keywords` (type: `string`):

Optional job title or skill filter applied within each location.

## `maxItemsPerLocation` (type: `integer`):

Safety cap for each location. Reaching it marks that location incomplete in OUTPUT\_SUMMARY.

## `maxTotalItems` (type: `integer`):

Maximum returned jobs across the full location comparison.

## `maxTotalPages` (type: `integer`):

Maximum result-page requests across the full run. Reaching it marks the run incomplete.

## Actor input object example

```json
{
  "locations": [
    "Germany"
  ],
  "maxItemsPerLocation": 100,
  "maxTotalItems": 5000,
  "maxTotalPages": 200
}
```

# 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 = {
    "locations": [
        "Germany"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apixyz/linkedin-jobs-by-location").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 = { "locations": ["Germany"] }

# Run the Actor and wait for it to finish
run = client.actor("apixyz/linkedin-jobs-by-location").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 '{
  "locations": [
    "Germany"
  ]
}' |
apify call apixyz/linkedin-jobs-by-location --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apixyz/linkedin-jobs-by-location",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs by Location",
        "description": "Compare one LinkedIn guest job search across up to 20 locations. Export structured job cards labeled by the requested market. No login or cookies.",
        "version": "0.2",
        "x-build-id": "oHOi5dLok4feOebTg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apixyz~linkedin-jobs-by-location/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apixyz-linkedin-jobs-by-location",
                "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/apixyz~linkedin-jobs-by-location/runs": {
            "post": {
                "operationId": "runs-sync-apixyz-linkedin-jobs-by-location",
                "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/apixyz~linkedin-jobs-by-location/run-sync": {
            "post": {
                "operationId": "run-sync-apixyz-linkedin-jobs-by-location",
                "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": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Add one to 20 cities, regions, or countries. Each location is searched and reported separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Optional job title or skill filter applied within each location."
                    },
                    "maxItemsPerLocation": {
                        "title": "Max jobs per location",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap for each location. Reaching it marks that location incomplete in OUTPUT_SUMMARY.",
                        "default": 100
                    },
                    "maxTotalItems": {
                        "title": "Max jobs for the run",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum returned jobs across the full location comparison.",
                        "default": 5000
                    },
                    "maxTotalPages": {
                        "title": "Max result pages for the run",
                        "minimum": 1,
                        "maximum": 400,
                        "type": "integer",
                        "description": "Maximum result-page requests across the full run. Reaching it marks the run incomplete.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
