# LinkedIn Company Jobs Search > LinkedIn Company Jobs Search is a paid API for AI agents from agents.openwebninja.com, paid per call via MPP, price unknown, status unknown (last checked 2026-10-14). Fetches all open LinkedIn job postings for one or more specified companies, with optional keyword, location, and pagination filters. ## Facts - Endpoint: GET https://agents.openwebninja.com/realtime-linkedin-data/company-jobs?utm_source=zero.xyz - Price: price unknown - Payment: MPP - Status: unknown - Last checked: 2026-10-14 - Activations on Zero: 0 - Provider: agents.openwebninja.com - Website: https://agents.openwebninja.com - Canonical page: https://www.zero.xyz/c/agents-openwebninja-com-linkedin-company-jobs-search-fcceee95 - Structured record (JSON): https://api.zero.xyz/v1/capabilities/cap_0ETzdbcxJWdRIlpRBlUai Status and success rate cover calls made through Zero and Zero's own probes. Third-party monitors may report differently. ## How to call it through Zero Zero handles the 402 payment challenge and records the run. With the Zero CLI installed (`npm i -g @zeroxyz/cli`): ```sh zero fetch --capability agents-openwebninja-com-linkedin-company-jobs-search-fcceee95 ``` Example prompt: Can you pull all the current open job postings on LinkedIn for Microsoft and Salesforce — filter to software engineering roles posted in the last week in New York? ## When to prefer this Use this endpoint when you need to enumerate all open positions at one or more known companies by name or LinkedIn company ID, rather than doing a broad keyword job search. It is ideal for competitive intelligence, recruiting pipelines, or monitoring a watchlist of employers. Prefer it over the generic /search endpoint when the company identity is the primary filter and keywords are optional refinements. ## Known failure modes - Unknown company slug returns 404 and fails the entire request - Providing radius without geo_id returns 400 - Providing more than one query parameter returns 400 - Unknown field name in fields projection returns 400 - page × 10 exceeding LinkedIn's 1000-result ceiling returns an error - Rate limiting or upstream LinkedIn changes may return 429 or 503 - Mixed valid/invalid slugs in a comma-separated list fail the whole batch ## How this service works Every open LinkedIn job posting at one or more companies. This is the **same search path** as `/search` with LinkedIn's `f_C` company filter populated — the same parser, the same fetch layer, the same job builder, the same 35-key superset contract and the same `job_id` codec. Every filter `/search` supports is supported here and composes with the company filter; that composition was verified live against `f_C=1035` (Microsoft), checking every card of every probe: `f_C` alone, `+ date_posted`, `+ location`, `+ geo_id` & `radius`, `+ query` and `+ page` each returned 10/10 jobs at the requested company. **Identifying a company.** Pass `company_id` (numeric, LinkedIn's own id — it is returned on every job as `job_linkedin_company_id`) or `company` (a vanity slug or company page URL, resolved live at the cost of one extra request). Both accept a comma-separated list of up to 10; ids and slugs may be mixed, and the union actually searched is echoed as `parameters.company_ids_resolved`. **Multiple companies are an OR**, not a round-robin. LinkedIn ranks the union by relevance, so a small company paired with a large one can be absent from page 1 entirely. The guarantee is that every job returned belongs to one of the requested companies — not that every requested company appears. **`query` is optional here**, unlike on `/search`: the company is the query. Supply it only to filter within the company's postings. **Pagination, `include_details`, local filters and billing behave exactly as on `/search`**, with one addition: each `company` slug resolution is billed as one request on top of the search pages. **A company with no open jobs returns an empty array**, and so does a numeric `company_id` that does not exist — LinkedIn answers both with the same empty page. Use `company` (the slug form) when you need a bad identifier to be an error instead. ## Output Returns a paginated array of up to 10 job objects per page, each containing 35 fields including job_id, job_title, employer_name, employer_logo, job_description, job_location (city/state/country/lat/lon), job_employment_type, job_is_remote, job_posted_at, job_apply_link, job_salary (min/max/period/currency), job_seniority_level, job_function, job_industries, job_applicants_count, and apply_options. Also returns a parameters object echoing company_ids_resolved and pagination metadata. ## Request schema (JSON Schema) ```json { "type": "object", "required": [ "company" ], "properties": { "page": { "type": "integer", "default": 1, "maximum": 100, "minimum": 1, "description": "1-based page number, 10 jobs per page. Capped at 100 by LinkedIn's 1000-result ceiling; `page + num_pages` may not cross it either." }, "query": { "type": "string", "description": "Optional free-form keyword filter (LinkedIn's `keywords`) applied **within** the selected companies. Omit it to get the company's whole job list — verified live that `f_C` alone is a valid upstream request. Only one `query` is accepted; a second one is rejected with a 400 rather than silently ignored." }, "fields": { "type": "string", "description": "Comma-separated projection over the job object. `job_id` and `job_title` are always included. An unknown field is a 400." }, "geo_id": { "type": "string", "description": "LinkedIn numeric geo id (e.g. `102571732` = New York City, `103644278` = United States). Required if you want `radius` to take effect. There is no geo-id lookup endpoint in this API yet — take the value from a `geoId=` parameter on a linkedin.com/jobs URL." }, "radius": { "type": "integer", "minimum": 1, "description": "Search radius in **kilometres**, converted to the miles LinkedIn expects. Passed through continuously, not as a coarse menu. **Requires `geo_id`.** LinkedIn ignores `distance` with a free-text location, so `radius` without `geo_id` is rejected with a 400 rather than silently doing nothing." }, "company": { "type": "string", "example": "microsoft", "description": "Comma-separated LinkedIn company vanity slugs or company page URLs, up to 10, resolved live to the ids `company_id` takes. `microsoft`, `/company/microsoft` and a full URL all work. Each slug costs **one extra billed request**. An unknown slug is a 404, and one bad slug fails the whole request." }, "country": { "type": "string", "default": "us", "description": "2-letter country code. Selects the proxy exit market and is the fallback for `job_country` when the posting's own location does not name a country. Geography is driven primarily by `location` / `geo_id`, not by this." }, "sort_by": { "enum": [ "relevance", "date" ], "type": "string", "default": "relevance", "description": "`relevance` leaves LinkedIn's own ordering alone. `date` sorts **the jobs in this response** newest-first — it does not re-rank the result set upst … (truncated) ``` ## Response schema (JSON Schema) ```json { "type": "object", "required": [ "status", "request_id", "parameters", "data" ], "properties": { "data": { "type": "array", "items": { "type": "object", "required": [ "job_id", "job_title", "employer_name", "employer_logo", "employer_website", "job_publisher", "job_employment_type", "job_employment_types", "job_apply_link", "job_apply_is_direct", "apply_options", "job_description", "job_is_remote", "job_posted_at", "job_posted_at_timestamp", "job_posted_at_datetime_utc", "job_location", "job_city", "job_state", "job_country", "job_latitude", "job_longitude", "job_benefits", "job_benefits_strings", "job_google_link", "job_salary", "job_salary_string", "job_min_salary", "job_max_salary", "job_salary_period", "job_highlights", "job_onet_soc", "job_onet_job_zone", "employer_reviews", "job_uid", "employer_linkedin_url", "job_linkedin_company_id", "job_seniority_level", "job_function", "job_industries", "job_applicants_count", "job_applicants_label", "job_salary_currency", "job_posted_at_date", "job_posted_at_linkedin_label", "job_linkedin_badges", "job_position" ], "properties": { "job_id": { "type": "string", "example": "bGlua2VkaW46NDQ1MzY3MDk3Mw", "description": "Opaque public id: `base64url(\"linkedin:\" + )`. Pass it back to `/job-details`. Stable for the life of the posting." }, "job_uid": { "type": "string", "example": "4453670973", "description": "The raw numeric LinkedIn posting id. Permanent, and accepted directly by `/job-details`." }, "job_city": { "type": "string", "example": "New York", "nullable": true }, "job_state": { "type": "string", "example": "New York", "nullable": true, "description": "US 2-letter codes are expanded to the full state name, matching JSearch." }, "job_title": { "type": "string", "example": "Software Engineer III (Java/AWS)" }, "job_salary": { "type": "number", "example": null, "nullable": true, "description": "Set only when a posting states a single figure rather than a range; a range populates `job_min_salary` / `job_max_salary` instead." }, "job_country": { "typ … (truncated) ``` ## More - Live health (JSON, refreshed every minute): https://www.zero.xyz/c/agents-openwebninja-com-linkedin-company-jobs-search-fcceee95/health.json - [Zero catalog index](https://www.zero.xyz/llms.txt) - [Other services from agents.openwebninja.com](https://www.zero.xyz/host/agents.openwebninja.com/llms.txt)