# Climatebase Jobs API (`cdex/climatebase-jobs-api`) Actor

Search live climatebase, sustainability, and green-tech job listings with filters for keywords, employers, locations, sectors, remote work, and job types.

- **URL**: https://apify.com/cdex/climatebase-jobs-api.md
- **Developed by:** [Can Demir](https://apify.com/cdex) (community)
- **Categories:** Jobs, Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 88.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

Climate Jobs API

Find live climate, sustainability, clean-energy, carbon-removal, and green-tech jobs through a simple JSON API.

Climate Jobs API is built for recruiters, job boards, researchers, newsletters, AI assistants, and automation workflows that need structured climate-career data without building or maintaining their own scraper.

### Why use Climate Jobs API?

- **Climate-focused data** — Discover roles across clean energy, sustainability, transportation, carbon removal, conservation, and related industries.
- **Live results** — Requests are forwarded to a continuously maintained backend and refreshed by the service owner.
- **Rich job records** — Get titles, employers, salaries, locations, sectors, remote preferences, job types, application details, descriptions, logos, dates, and more when available.
- **Raw source fields included** — Every result can include `raw_data`, preserving the complete structured record received from the source index.
- **Simple filters** — Search by keyword, employer, remote preference, and page.
- **Developer-friendly JSON** — Use the API from Python, JavaScript, Make, Zapier, n8n, dashboards, job boards, or AI workflows.
- **No scraping infrastructure required** — No browser automation, proxy setup, or database management is needed on your side.

### Try it free

The interactive Actor run returns up to **10 sample jobs**, so you can evaluate the data before integrating it.

For larger responses and live API access, use the Actor’s Standby endpoint.

### API endpoint

```text
GET /api/jobs
````

The Standby endpoint returns the live paginated response from the backend API.

#### Query parameters

| Parameter | Type | Description |
|---|---|---|
| `keyword` | string | Searches job titles. Example: `solar` |
| `employer` | string | Filters by employer name. |
| `is_remote` | boolean | Set to `true` to find remote opportunities. |
| `page` | integer | Selects the result page. Defaults to `1`. |

### Quick start

Replace `YOUR_STANDBY_URL` with the Standby URL shown on the Actor page:

```bash
curl "https://YOUR_STANDBY_URL/api/jobs?keyword=solar&is_remote=true&page=1" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

### Example searches

Search for solar jobs:

```text
/api/jobs?keyword=solar
```

Find remote climate roles:

```text
/api/jobs?is_remote=true
```

Search for a specific employer:

```text
/api/jobs?employer=Energy
```

Combine filters:

```text
/api/jobs?keyword=engineer&is_remote=true&page=1
```

### Example response

```json
{
  "items": [
    {
      "id": 46360304,
      "url": "https://climatebase.org/job/46360304",
      "title": "Laboratory Technician",
      "employer_name": "Example Climate Company",
      "salary_from": "70000",
      "salary_to": "95000",
      "locations": ["Marlborough, MA, US"],
      "sectors": ["Food, Agriculture, & Land Use"],
      "remote_preferences": ["In-person"],
      "job_types": ["Full time role"],
      "raw_data": {
        "description": "Full job description when available",
        "how_to_apply": "Application instructions when available",
        "salary_period": "year",
        "logo": "https://example.com/logo.png",
        "experience_levels": ["Mid-level"],
        "countries": ["US"]
      }
    }
  ],
  "count": 1212
}
```

`raw_data` may contain additional source fields such as:

- job description and application instructions;
- salary period and compensation details;
- employer description, logo, and employer status;
- activation, expiration, and creation dates;
- categories, sub-categories, sectors, and industries;
- remote preferences, time zones, countries, and locations;
- experience levels, organization type, and organization size;
- networks, drawdown solutions, and other source-specific metadata.

Fields can be empty when the original listing does not provide that information.

### Use cases

#### Recruiting and talent sourcing

Find climate-tech candidates and opportunities by title, employer, location, or remote preference.

#### Climate job boards

Power a searchable job board with structured listings and direct links to the original postings.

#### Research and market intelligence

Analyze hiring trends across climate sectors, companies, countries, and experience levels.

#### Newsletters and alerts

Create curated weekly job lists or automated alerts for specific climate-career keywords.

#### AI assistants and automation

Give an AI agent structured access to current climate jobs for search, matching, ranking, and recommendations.

### Python example

```python
import requests

url = "https://YOUR_STANDBY_URL/api/jobs"
params = {
    "keyword": "wind engineer",
    "is_remote": True,
    "page": 1,
}
headers = {"Authorization": "Bearer YOUR_APIFY_TOKEN"}

response = requests.get(url, params=params, headers=headers, timeout=60)
response.raise_for_status()

for job in response.json().get("items", []):
    print(job["title"], job.get("url"))
```

### JavaScript example

```javascript
const url = new URL('https://YOUR_STANDBY_URL/api/jobs');
url.searchParams.set('keyword', 'solar');
url.searchParams.set('is_remote', 'true');
url.searchParams.set('page', '1');

const response = await fetch(url, {
    headers: { Authorization: 'Bearer YOUR_APIFY_TOKEN' },
});

const data = await response.json();
console.log(data.items);
```

### Data freshness and links

The Actor proxies requests to the live service rather than packaging a static database. Job links point to the original Climatebase listing whenever a canonical job ID is available. A listing may still return an error if the original posting has later been removed or expired.

### Integrations

Use the API with:

- Python, JavaScript, Node.js, PHP, Ruby, or Go;
- Apify Tasks and other Actors;
- Make, Zapier, n8n, and custom webhooks;
- AI agents and MCP-compatible workflows;
- recruiting dashboards and job boards;
- scheduled newsletters and internal research tools.

### Responsible use

Please verify that your intended redistribution, automated access, and commercial use comply with the terms and policies of the original data source.

### Support

If you need a specific filter, output field, integration, or higher-volume workflow, contact the author through the Apify Actor page.

# Actor input Schema

## `keyword` (type: `string`):

Searches job title and employer name.

## `employer` (type: `string`):

Filters by employer name.

## `location` (type: `string`):

Filters locations, for example Remote, Europe or United States.

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

Filters sectors such as Energy, Nature or Carbon Removal.

## `remoteOnly` (type: `boolean`):

Return only jobs whose remote preferences contain Remote.

## `jobType` (type: `string`):

Filters job types such as Full-time, Part-time or Contract.

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

Maximum number of results to return.

## `page` (type: `integer`):

1-based page number when using a result limit.

## Actor input object example

```json
{
  "remoteOnly": false,
  "limit": 100,
  "page": 1
}
```

# 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("cdex/climatebase-jobs-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("cdex/climatebase-jobs-api").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 '{}' |
apify call cdex/climatebase-jobs-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Climatebase Jobs API",
        "description": "Search live climatebase, sustainability, and green-tech job listings with filters for keywords, employers, locations, sectors, remote work, and job types.",
        "version": "1.0",
        "x-build-id": "1LlTAVTraxmC7p7X7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cdex~climatebase-jobs-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cdex-climatebase-jobs-api",
                "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/cdex~climatebase-jobs-api/runs": {
            "post": {
                "operationId": "runs-sync-cdex-climatebase-jobs-api",
                "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/cdex~climatebase-jobs-api/run-sync": {
            "post": {
                "operationId": "run-sync-cdex-climatebase-jobs-api",
                "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": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Searches job title and employer name."
                    },
                    "employer": {
                        "title": "Employer",
                        "type": "string",
                        "description": "Filters by employer name."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filters locations, for example Remote, Europe or United States."
                    },
                    "sector": {
                        "title": "Sector",
                        "type": "string",
                        "description": "Filters sectors such as Energy, Nature or Carbon Removal."
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Return only jobs whose remote preferences contain Remote.",
                        "default": false
                    },
                    "jobType": {
                        "title": "Job type",
                        "type": "string",
                        "description": "Filters job types such as Full-time, Part-time or Contract."
                    },
                    "limit": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of results to return.",
                        "default": 100
                    },
                    "page": {
                        "title": "Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "1-based page number when using a result limit.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```