# RemoteOK Jobs Scraper - Search & All Current Remote Jobs (`lentic_clockss/remoteok-all-jobs-scraper`) Actor

Search current RemoteOK jobs by keyword or export all current remote roles with salary, tags, location, apply links, and normalized fields for hiring and lead workflows.

- **URL**: https://apify.com/lentic\_clockss/remoteok-all-jobs-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## RemoteOK Jobs Scraper - Search & Export All Current Remote Jobs

**Search or filter RemoteOK jobs by keyword, geo, and industry/tag, or export every current remote job listing with salary, tags, location, and application links as a clean Dataset.** This Actor pulls the public RemoteOK job feed and returns normalized, deduplicated job records ready for spreadsheets, dashboards, recruitment pipelines, or AI agent workflows.

Use `searchQuery`, `geo`, and/or `industry` to narrow results, or leave them empty to export all current listings. Every row includes the original API object in a `raw` field so you never lose upstream data. There are no preset keywords, geos, or industries.

### Why use this RemoteOK Scraper?

- **Keyword search**: enter `searchQuery` to filter current RemoteOK jobs by title, company, description, tags, location, slug, and URLs.
- **Geo filter**: enter `geo` (for example `usa`, `uk`, `europe`, `india`, `worldwide`) to match location text with common region aliases.
- **Industry / tag filter**: enter `industry` (for example `dev`, `python`, `marketing`, `customer support`) to request RemoteOK with the official `tag` query and keep matching rows.
- **Full-feed export**: leave filters empty to get every valid job record in the current RemoteOK API response.
- **Structured output**: normalized fields for title, company, salary, tags, location, posting date, job URL, and apply URL.
- **Original raw data**: each row preserves the unmodified upstream API object in a `raw` field.
- **Deduplication**: response-local duplicates and malformed records are skipped, with counts reported in `RUN_SUMMARY`.
- **Filter provenance**: filtered rows include `sourceSearchQuery` / `searchRank` and/or `sourceGeo` / `sourceIndustry` / `filterRank`.
- **No credentials needed**: the Actor uses the public RemoteOK API and does not require any API key or login.
- **Attribution built in**: `source_url` and `attribution_url` fields make it easy to link back to RemoteOK.

### Tutorial

1. Click **Try for free** on this Actor page.
2. Optionally enter `searchQuery` (e.g. `python`, `frontend`, `devops`).
3. Optionally enter `geo` (e.g. `usa`, `uk`, `worldwide`) and/or `industry` (e.g. `dev`, `marketing`).
4. To export all current jobs, leave `searchQuery`, `geo`, and `industry` empty.
5. Optionally set `maxItems` to cap the output size. `0` means no limit.
6. Click **Start** and wait for the run to finish.
7. Open the **Dataset** tab to download results as JSON, CSV, Excel, or JSONL.
8. Check `RUN_SUMMARY` in the key-value store for source counts, duplicates skipped, and malformed records.

#### Example inputs

All-current-jobs mode (empty input):

```json
{}
````

Keyword search mode:

```json
{
  "searchQuery": "python",
  "maxItems": 25
}
```

Geo + industry filter:

```json
{
  "geo": "usa",
  "industry": "dev",
  "maxItems": 50
}
```

Keyword + geo + industry:

```json
{
  "searchQuery": "python",
  "geo": "europe",
  "industry": "dev",
  "maxItems": 25
}
```

### Input and output examples

#### Input fields

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQuery` | string | empty | Optional keyword or phrase. When set, the Actor filters current RemoteOK API job records by title, company, description, tags, location, slug, job URL, and application URL. |
| `geo` | string | empty | Optional region slug or free-text location filter. Common aliases are listed in **Common geo slugs**. Leave empty for all regions. |
| `industry` | string | empty | Optional RemoteOK tag/industry slug. Common values are listed in **Common industry / tag slugs**. Spaces, hyphens, and underscores are accepted (`customer support` = `customer-support`). |
| `maxItems` | integer | `0` | Maximum matching job records to emit. `0` means no client-side limit. Maximum `5000`. |

#### Output item example

```json
{
  "id": "123456",
  "record_type": "job",
  "title": "Senior Python Developer",
  "company_name": "Example Co",
  "company_logo": "https://remoteok.com/assets/img/logo.png",
  "description": "We are looking for a senior Python developer...",
  "tags": ["python", "django", "remote"],
  "location": "Worldwide",
  "salary": "$80,000-$120,000/yr",
  "salary_min": 80000,
  "salary_max": 120000,
  "original_created_at": "2026-07-15T00:00:00+00:00",
  "epoch": "1784073600",
  "url": "https://remoteok.com/remote-jobs/123456",
  "apply_url": "https://example.com/apply",
  "slug": "senior-python-developer-example-co",
  "source_url": "https://remoteok.com/remote-jobs/123456",
  "source": "remoteok",
  "sourceSearchQuery": "python",
  "searchRank": 1,
  "sourceGeo": "usa",
  "sourceIndustry": "dev",
  "attribution_url": "https://remoteok.com",
  "crawled_at": "2026-07-15T09:00:00+00:00",
  "raw": {"id": "123456", "position": "Senior Python Developer", "company": "Example Co"}
}
```

In all-current-jobs mode, filter provenance fields are absent. In keyword mode, rows include `sourceSearchQuery` and `searchRank`. In geo/industry-only mode, rows include `sourceGeo` / `sourceIndustry` and `filterRank` as applicable.

#### Output fields

| Field | Description |
| --- | --- |
| `id` | RemoteOK job ID. |
| `record_type` | Always `job`. |
| `title` | Job title / position. |
| `company_name` | Hiring company name. |
| `company_logo` | Company logo URL when available. |
| `description` | Full job description text when available. |
| `tags` | Job tags (e.g. `python`, `remote`, `senior`). |
| `location` | Job location; defaults to `remote` when not specified. |
| `salary` | Formatted salary range string (e.g. `$80,000-$120,000/yr`). |
| `salary_min`, `salary_max` | Numeric salary bounds when available. |
| `original_created_at` | Original posting date from RemoteOK. |
| `epoch` | Epoch timestamp as string. |
| `url` | RemoteOK job URL when provided by the API. |
| `apply_url` | Direct application URL when available. |
| `slug` | URL slug for the job. |
| `source_url` | Constructed or provided RemoteOK job URL. |
| `source` | Always `remoteok`. |
| `sourceSearchQuery` | The keyword used when in search mode. |
| `searchRank` | Match rank (1-based) when in search mode. |
| `sourceGeo` | The `geo` filter used when set. |
| `sourceIndustry` | The `industry` filter used when set. |
| `filterRank` | Match rank (1-based) when geo/industry filters are set without keyword search. |
| `attribution_url` | `https://remoteok.com` for attribution. |
| `crawled_at` | ISO timestamp when this Actor collected the row. |
| `raw` | The original unmodified RemoteOK API record. |

#### Run artifacts

| Artifact | When it is written | What it contains |
| --- | --- | --- |
| `INPUT_ECHO` | After valid input parsing | Normalized scope, keyword, geo, industry, and limits. |
| `RUN_SUMMARY` | After a successful run | Source, filters, record counts, duplicates, malformed records, warnings, and timestamps. |
| `ERROR_SUMMARY` | When a run fails | Error type, safe error message, and timestamps. |

### Common geo slugs

`geo` is matched against RemoteOK location text (and related free-text fields). Use either a short slug or free text. Multi-word values may use spaces or hyphens.

| Slug / input | Also matches | Notes |
| --- | --- | --- |
| `usa` | `us`, `united-states`, `united states`, `u.s.`, `u.s.a.` | United States |
| `uk` | `united-kingdom`, `united kingdom`, `england`, `scotland`, `wales`, `britain` | United Kingdom |
| `europe` | `eu`, `emea` | Europe / EMEA-style labels |
| `emea` | `emea`, `europe` | EMEA-style labels |
| `apac` | `asia`, `pacific` | Asia-Pacific-style labels |
| `latam` | `latin america`, `south america` | Latin America |
| `canada` | `canadian` | Canada |
| `germany` | `deutschland`, `berlin`, `munich` | Germany |
| `france` | `paris` | France |
| `netherlands` | `holland`, `amsterdam` | Netherlands |
| `spain` | `espana`, `españa`, `madrid`, `barcelona` | Spain |
| `ireland` | `dublin` | Ireland |
| `australia` | `sydney`, `melbourne` | Australia |
| `singapore` | `singapore` | Singapore |
| `japan` | `tokyo` | Japan |
| `india` | `bangalore`, `bengaluru`, `mumbai`, `delhi`, `hyderabad`, `chennai`, `pune` | India |
| `brazil` | `brasil`, `sao paulo`, `são paulo` | Brazil |
| `mexico` | `méxico` | Mexico |
| `philippines` | `manila` | Philippines |
| `worldwide` | `world wide`, `anywhere`, `global`, `remote` | Global / remote-friendly labels |
| `remote` | `remote`, `worldwide`, `anywhere`, `global` | Same family as worldwide |

Any other free-text value is also accepted and matched as-is (plus hyphen/space variants). RemoteOK does **not** expose a reliable server-side location query on the public API, so geo filtering is applied on the current feed returned at run time.

### Common industry / tag slugs

`industry` maps to RemoteOK tags. When set, the Actor calls `https://remoteok.com/api?tag=...` and still applies a local tag match so only relevant rows are emitted. Spaces, hyphens, and underscores are interchangeable.

| Slug | Examples of accepted forms | Typical use |
| --- | --- | --- |
| `dev` | `dev` | Software development |
| `web-dev` | `web dev`, `web-dev` | Web development |
| `python` | `python` | Python roles |
| `javascript` | `javascript` | JavaScript roles |
| `react` | `react` | React roles |
| `design` | `design`, `designer` | Design |
| `marketing` | `marketing` | Marketing |
| `customer-support` | `customer support`, `customer-support`, `support` | Customer support |
| `digital-nomad` | `digital nomad`, `digital-nomad` | Digital nomad friendly |
| `exec` | `exec` | Executive / leadership |
| `ops` | `ops` | Operations |
| `education` | `education`, `teaching` | Education |
| `medical` | `medical` | Medical / healthcare |
| `content-writing` | `content writing`, `content-writing`, `copywriting` | Content / writing |
| `technical` | `technical` | Technical roles |
| `sys-admin` | `sys admin`, `sys-admin` | Sysadmin |
| `finance` | `finance` | Finance |
| `sales` | `sales` | Sales |
| `hr` | `hr`, `recruiter` | HR / recruiting |
| `legal` | `legal` | Legal |
| `testing` | `testing` | QA / testing |
| `mobile` | `mobile` | Mobile |
| `video` | `video` | Video |
| `social-media` | `social media`, `social-media` | Social media |
| `virtual-assistant` | `virtual assistant`, `virtual-assistant` | Virtual assistant |
| `data-entry` | `data entry`, `data-entry`, `analyst` | Data / analysis-related tags |
| `engineer` | `engineer` | Engineering labels |
| `non-tech` | `non tech`, `non-tech` | Non-tech roles |
| `full-time` | `full time`, `full-time` | Employment type tag |

RemoteOK tag inventory changes over time. If a tag is rare or unused on the current feed, the run can succeed with zero rows and a clear `RUN_SUMMARY`.

### Data source and search boundary

This Actor uses the public RemoteOK API endpoint (`https://remoteok.com/api`) at run time. RemoteOK decides which current job records are present in that response.

- `searchQuery` filters the current API payload locally.
- `industry` requests the official `tag` query and also filters locally.
- `geo` filters the returned payload locally against location/text fields.
- The Actor does not query a separate RemoteOK historical index and does not paginate through older jobs.

Unsupported aliases such as `query`, `keyword`, `keywords`, `tags`, `tag`, and `location` are rejected. Use the canonical fields `searchQuery`, `geo`, and `industry` so automation does not silently change scope.

### Pricing

**Pay per event. No subscription.** Apify displays the effective event price before each run.

| Event | Price | When it is charged |
| --- | ---: | --- |
| `apify-actor-start` | **$0.005** | Automatically once when a normal Actor run starts. |
| `apify-default-dataset-item` | **$2.00 / 1,000** | Automatically for each item written to the default Dataset. |

For example, a run returning 100 job records costs **$0.205** in Actor events: $0.005 to start plus $0.200 for results. Platform usage costs are charged to the user in addition to these Actor events, as shown by Apify before a run.

Both listed events are Apify synthetic events: the platform accounts for them automatically, so the Actor does not manually issue duplicate charges in code.

### Live View and Standby endpoints

This Actor exposes an honest lightweight Live View service. Data collection stays in normal Actor runs; the standby service does not pretend to offer a separate scrape API.

| Endpoint | Purpose |
| --- | --- |
| `GET /` | Readiness and service information. |
| `GET /health` | Fast health check. |
| `GET /input-example` | Low-cost input compatible with the Actor schema. |
| `GET /openapi.json` | The deployed OpenAPI 3.x contract. |

The interactive **Standby** tab on Apify renders these endpoints from the same OpenAPI document served by the Actor.

### Connect from code or an AI workflow

Use this Actor in Apify, Make, Zapier, n8n, or an agent workflow. The Actor ID is `lentic_clockss/remoteok-all-jobs-scraper`.

<details>
<summary>Python example</summary>

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("lentic_clockss/remoteok-all-jobs-scraper").call(
    run_input={
        "searchQuery": "python",
        "geo": "usa",
        "industry": "dev",
        "maxItems": 25,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company_name"], item["tags"], item["source_url"])
```

</details>

### Related Actors

Use this Actor when RemoteOK is the source of record. For other job boards, keep a separate Actor and join their Datasets in your own workflow so source attribution, data freshness, and each platform's usage terms remain clear.

### FAQ and support

**Does it search RemoteOK by keyword?** Yes. Set `searchQuery` to a word or phrase. The Actor filters the current RemoteOK API job records and returns matching jobs with `sourceSearchQuery` and `searchRank`.

**Can I filter by region or industry?** Yes. Use `geo` and/or `industry`. See the slug tables above. Filtered rows include `sourceGeo` / `sourceIndustry` provenance.

**Does "all" include RemoteOK history?** No. "All" means all valid job records in the API response at run time. The RemoteOK endpoint itself decides which current records it returns and does not expose a historical pagination option here.

**What happens when there are no matches?** If any of `searchQuery`, `geo`, or `industry` is set and nothing matches, the run succeeds with zero Dataset rows and a clear `RUN_SUMMARY` showing the filters and `recordsEmitted: 0`. That is different from a source failure, which writes `ERROR_SUMMARY` and fails.

**Can I publish the results commercially?** Check the upstream notice and [RemoteOK terms](https://remoteok.com/legal) before use. The API metadata says the API is free for non-commercial use, and RemoteOK's terms require a hyperlink back where API or site data is used. Keep `source_url` and `attribution_url`, link back visibly, and obtain written permission before commercial redistribution or Store publication.

**Where can I report a problem?** Include the Actor run ID, `RUN_SUMMARY` or `ERROR_SUMMARY`, and one example `source_url` in your support request. Never include credentials because this Actor does not need any.

***

Explore more tools from [lentic\_clockss on Apify](https://apify.com/lentic_clockss).

# Actor input Schema

## `searchQuery` (type: `string`):

Optional keyword or phrase. When set, the Actor filters current RemoteOK job records by title, company, description, tags, location, slug, and URLs.

## `geo` (type: `string`):

Optional region slug or free-text location filter matched against RemoteOK location fields. Common slugs: usa, uk, europe, india, canada, worldwide. See README geo slug table. Leave empty for all regions.

## `industry` (type: `string`):

Optional RemoteOK tag/industry slug (for example dev, python, marketing, customer support). Spaces and hyphens are interchangeable. When set, the Actor requests RemoteOK with the official tag query and keeps matching rows. See README industry slug table.

## `maxItems` (type: `integer`):

Set 0 to keep every matching current RemoteOK job record returned by the API. Use a positive number only when you deliberately want a smaller output.

## Actor input object example

```json
{
  "searchQuery": "python",
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

All valid matching job records returned by the RemoteOK API unless the user explicitly sets maxItems.

## `runSummary` (type: `string`):

Source, search query, counts for the source response, emitted records, duplicates, and malformed records.

## `inputEcho` (type: `string`):

Normalized non-secret input showing the actual collection or search scope.

## `errorSummary` (type: `string`):

Structured failure details when input validation or source acquisition fails.

# 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 = {
    "searchQuery": "python",
    "geo": "",
    "industry": "",
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/remoteok-all-jobs-scraper").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 = {
    "searchQuery": "python",
    "geo": "",
    "industry": "",
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/remoteok-all-jobs-scraper").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 '{
  "searchQuery": "python",
  "geo": "",
  "industry": "",
  "maxItems": 0
}' |
apify call lentic_clockss/remoteok-all-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RemoteOK Jobs Scraper - Search & All Current Remote Jobs",
        "description": "Search current RemoteOK jobs by keyword or export all current remote roles with salary, tags, location, apply links, and normalized fields for hiring and lead workflows.",
        "version": "0.1",
        "x-build-id": "uy9rx1awdTBtUKop4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~remoteok-all-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-remoteok-all-jobs-scraper",
                "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/lentic_clockss~remoteok-all-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-remoteok-all-jobs-scraper",
                "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/lentic_clockss~remoteok-all-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-remoteok-all-jobs-scraper",
                "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": {
                    "searchQuery": {
                        "title": "Search keyword",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Optional keyword or phrase. When set, the Actor filters current RemoteOK job records by title, company, description, tags, location, slug, and URLs."
                    },
                    "geo": {
                        "title": "Region / geo",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Optional region slug or free-text location filter matched against RemoteOK location fields. Common slugs: usa, uk, europe, india, canada, worldwide. See README geo slug table. Leave empty for all regions."
                    },
                    "industry": {
                        "title": "Industry / tag",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Optional RemoteOK tag/industry slug (for example dev, python, marketing, customer support). Spaces and hyphens are interchangeable. When set, the Actor requests RemoteOK with the official tag query and keeps matching rows. See README industry slug table."
                    },
                    "maxItems": {
                        "title": "Maximum job records (optional)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Set 0 to keep every matching current RemoteOK job record returned by the API. Use a positive number only when you deliberately want a smaller output.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
