# X (twitter) Jobs Search (`datamagnet/x-twitter-jobs-search`) Actor

Search X Jobs by keyword and return matching job listings in a simple, readable format.

- **URL**: https://apify.com/datamagnet/x-twitter-jobs-search.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Jobs, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.md):

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

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

## X Jobs Search Scraper

X Jobs Search is a simple job search scraper for finding matching job listings on X by keyword. It helps recruiters, job seekers, founders, and researchers quickly collect job titles, company names, locations, links, and posting details in one clean list. Instead of scrolling through noisy search results, you get a focused view of openings that match the role, skill, or phrase you care about. Use it to speed up job discovery, compare opportunities, and review fresh listings without technical complexity.

### Key Features

- **Extract** matching X job listings from a single search keyword.
- **Collect** the most relevant job details in a clean, readable format.
- **Review** job titles, company names, locations, and job links at a glance.
- **Capture** posting dates or times when they are available.
- **Summarize** short job descriptions so you can scan opportunities faster.
- **Compare** multiple openings side by side to spot the best fit.
- **Export** results for reporting, sharing, or further analysis.

### Use Cases

#### Job Search
Job seekers use this actor to find openings that match a title, skill, or phrase such as “developer,” “designer,” or “remote marketing.” The output gives them the job title, company name, location, and job URL so they can quickly decide which roles are worth opening and applying to. It is especially useful when someone wants to scan many listings without manually searching through social feeds.

#### Recruiter Sourcing
Recruiters can search for roles related to a specific function and review the company names and job summaries to understand hiring activity. This helps them identify which employers are actively posting similar roles and where the strongest demand is appearing. The job URL makes it easy to open the original listing and move from discovery to outreach faster.

#### Market Research
Analysts and founders can use the search results to track what kinds of jobs are being posted for a given keyword. By reviewing the title, location, and short description, they can spot hiring trends, common responsibilities, and geographic patterns. This is useful for understanding demand in a niche before launching a product, service, or campaign.

#### Competitive Intelligence
Businesses can search for roles related to their industry or competitors and see what positions are being advertised. The company name and posting details help teams understand where competitors are investing and what capabilities they are building. This can support sales strategy, partnership research, and broader market positioning.

#### Remote Work Discovery
People looking for flexible work can search for terms like “remote developer” or “remote support” and review the location field to identify suitable openings. The actor helps them focus on listings that match their preferred work style without reading every post manually. It is a practical way to build a shortlist of relevant opportunities quickly.

#### Content and Newsletter Curation
Writers, newsletter creators, and community managers can use the results to surface timely job openings for their audience. The job title, company name, and summary provide enough context to create curated lists or weekly roundups. This saves time and helps them publish useful, current content with less effort.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| query | string | Yes | Enter a job title, skill, or phrase to search for matching jobs. | superman |

### Output

| Field | Type | Description |
|---|---|---|
| search term | string | The keyword you searched for, so you can easily remember what the results are based on. |
| job title | string | The name of the role being advertised, helping you quickly see whether it matches your interest. |
| company name | string | The employer or organization posting the job, useful for comparing opportunities and identifying hiring companies. |
| location | string | Where the job is based or whether it appears to be remote, helping you filter by geography or work style. |
| job URL | string | A direct link to the original job listing so you can open the posting and review it in full. |
| posted date or time | string | When the job was posted, if available, so you can judge how fresh the listing is. |
| short job summary or description | string | A brief overview of the role that helps you understand the opportunity without reading the full post. |

### Sample Output

```json
{
  "search term": "developer"
}
````

### How It Works

1. You enter a search keyword such as a job title, skill, or phrase.
2. The actor searches for matching job listings on X.
3. It gathers the most useful details from each relevant posting.
4. The results are organized into a simple list that is easy to scan.
5. You review, export, or share the listings in the format that works best for you.

### Getting Started

Getting started is easy and does not require coding. Just click **Try for free**, enter your search keyword, and click **Run**. In a short time, you will get a clean list of matching job results that you can review right away. Your data is available in **JSON, CSV, or Excel**, making it simple to use for reporting, sharing, or further analysis.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users, recruiters, job seekers, and researchers who want quick results without dealing with complicated setup. You only need to enter a search keyword and run it.

#### How fast does it run?

It usually runs quickly because it only searches for the keyword you provide and returns matching job listings. The exact time depends on how many results are available for that search term.

#### What format is the output?

You can access the results in JSON, CSV, or Excel. That makes it easy to review the listings in a spreadsheet, share them with a team, or use them in your own workflow.

#### Is this legal to use?

This actor is intended for lawful research and job discovery use cases. You should always use the results responsibly and make sure your use complies with applicable laws, platform rules, and your organization’s policies.

#### Can I schedule it to run automatically?

Yes, you can set it up to run on a schedule if you want regular updates for a keyword or role. This is useful for tracking new job postings over time and staying current without manual searching.

# Actor input Schema

## `query` (type: `string`):

Enter a job title, skill, or phrase to search for matching jobs.

## Actor input object example

```json
{
  "query": "developer"
}
```

# 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 = {
    "query": "developer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/x-twitter-jobs-search").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 = { "query": "developer" }

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/x-twitter-jobs-search").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 '{
  "query": "developer"
}' |
apify call datamagnet/x-twitter-jobs-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X (twitter) Jobs Search",
        "description": "Search X Jobs by keyword and return matching job listings in a simple, readable format.",
        "version": "0.0",
        "x-build-id": "5jUTIV5fcpjfk9TPO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~x-twitter-jobs-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-x-twitter-jobs-search",
                "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/datamagnet~x-twitter-jobs-search/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-x-twitter-jobs-search",
                "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/datamagnet~x-twitter-jobs-search/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-x-twitter-jobs-search",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Enter a job title, skill, or phrase to search for matching jobs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
