# Bitcoinerjobs Scraper (`alichaudhry/bitcoinerjobs-scraper`) Actor

Unlock Bitcoin hiring data! Instantly extract detailed listings from BitcoinerJobs, a leading board for Bitcoin and Lightning roles. Perfect for market research, recruitment, or job aggregators. Get structured, up-to-date global opportunities quickly and effortlessly. Built for Bitcoin hiring intel.

- **URL**: https://apify.com/alichaudhry/bitcoinerjobs-scraper.md
- **Developed by:** [Ali Chaudhry](https://apify.com/alichaudhry) (community)
- **Categories:** Automation, Jobs, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.

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

### What does Bitcoiner Jobs Scraper do?

**Bitcoiner Jobs Scraper** extracts job listings from [Bitcoiner Jobs](https://bitcoinerjobs.com/), one of the most focused career platforms in the Bitcoin ecosystem. It is designed for teams and builders who need structured hiring data for analytics, recruiting workflows, and job aggregation products.

Run it on the Apify platform to get reliable API access, scheduling, integrations, monitoring, and scalable execution without managing infrastructure.

### Why use Bitcoiner Jobs Scraper?

- Track the Bitcoin hiring market with recurring snapshots.
- Build filtered talent pipelines for remote, hybrid, or location-specific roles.
- Analyze salary visibility, role categories, and hiring trends over time.
- Power newsletters, dashboards, and internal hiring intelligence with clean output.
- Automate downstream workflows through webhooks, Make, Zapier, Sheets, or custom APIs.

### How to use Bitcoiner Jobs Scraper

1. Open the Actor in Apify Console and click **Try for free**.
2. In the **Input** tab, set your `startUrls` (or use the default Bitcoiner Jobs listing URL).
3. Optionally set limits such as `maxRequestsPerCrawl` to control run size and cost.
4. Start with a small run to validate output shape and filtering behavior.
5. Click **Start** and wait for the run to finish.
6. Open the **Output** tab to inspect items, then export data or connect integrations.

### Input

Configure scraping behavior in the Actor **Input** tab. Current schema fields:

- `startUrls` (array): initial listing pages to crawl.
- `maxRequestsPerCrawl` (integer): cap on total requests in one run.

Example input:

```json
{
  "startUrls": [
    { "url": "https://bitcoinerjobs.com/jobs" }
  ],
  "maxRequestsPerCrawl": 100
}
````

### Output

Each dataset item represents one job record. Fields will evolve as extraction is finalized, but a typical output target looks like:

```json
{
  "id": "example-job-id",
  "title": "Bitcoin Backend Engineer",
  "company": "Example Bitcoin Company",
  "location": "Remote",
  "jobType": "Full-time",
  "salaryMin": 120000,
  "salaryMax": 180000,
  "salaryCurrency": "USD",
  "categories": ["Engineering"],
  "industry": "Infrastructure",
  "paysInBtc": true,
  "url": "https://bitcoinerjobs.com/jobs/example-job",
  "scrapedAt": "2026-04-28T17:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

Main fields this Actor is intended to output:

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | Unique identifier for the job listing |
| `title` | string | Job title |
| `company` | string | Hiring company name |
| `location` | string | Job location (remote, hybrid, city, country) |
| `jobType` | string | Employment type (full-time, part-time, contract, etc.) |
| `salaryMin` | number | Lower bound of salary range, if available |
| `salaryMax` | number | Upper bound of salary range, if available |
| `salaryCurrency` | string | Salary currency code |
| `categories` | array | Role categories |
| `industry` | string | Industry specialization |
| `paysInBtc` | boolean | Whether compensation in BTC is indicated |
| `url` | string | Link to job detail page |
| `scrapedAt` | string | ISO timestamp of extraction |

### Pricing / Cost estimation

How much does it cost to scrape Bitcoiner Jobs data?

- Small runs (dozens of jobs) are typically low-cost and useful for testing.
- Medium runs (full listing sweep with modest frequency) are suitable for weekly monitoring.
- Scheduled runs (daily/weekly) keep trend datasets current and easy to analyze.

Actual spend depends on page count, concurrency, retries, and schedule frequency. Start with a low `maxRequestsPerCrawl`, verify output quality, then scale gradually.

### Tips or Advanced options

- Start with one listing URL and a low request limit to validate selectors.
- Run on a schedule (daily or weekly) for market trend monitoring.
- Keep output schema stable once downstream automations depend on it.
- Use deduplication keys (for example `id` or canonical job URL) in post-processing.
- Export to CSV for quick analysis, and JSON for API/database pipelines.

### FAQ, disclaimers, and support

#### Is it legal to scrape job listings?

Use this Actor responsibly and ensure your use complies with applicable laws, website terms, and internal compliance requirements.

#### Why might some fields be empty?

Not every listing includes salary, location constraints, or compensation details. Missing values are expected for some records.

#### Can I monitor new jobs automatically?

Yes. Configure a schedule in Apify and route run results through integrations or webhooks for alerts.

#### How can I request a feature or report an issue?

Use the Actor Issues tab on Apify to share bugs, feature requests, or edge cases. For custom workflows, you can extend the Actor for your internal pipeline.

***

Reference style inspiration: [RemoteOk Job Scraper](https://apify.com/shahidirfan/remoteok-job-scraper#remoteok-jobs-scraper)

# Actor input Schema

## `startUrl` (type: `string`):

Bitcoiner Jobs page where crawling starts.

## `keywords` (type: `array`):

Only include jobs matching at least one keyword.

## `locationFilters` (type: `array`):

Filter jobs by remote mode.

## `maxListings` (type: `integer`):

Maximum number of job listings to save.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy configuration.

## Actor input object example

```json
{
  "startUrl": "https://bitcoinerjobs.com/",
  "keywords": [],
  "locationFilters": [],
  "maxListings": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "checkAccess": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrl": "https://bitcoinerjobs.com/",
    "keywords": [],
    "locationFilters": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("alichaudhry/bitcoinerjobs-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 = {
    "startUrl": "https://bitcoinerjobs.com/",
    "keywords": [],
    "locationFilters": [],
}

# Run the Actor and wait for it to finish
run = client.actor("alichaudhry/bitcoinerjobs-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 '{
  "startUrl": "https://bitcoinerjobs.com/",
  "keywords": [],
  "locationFilters": []
}' |
apify call alichaudhry/bitcoinerjobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bitcoinerjobs Scraper",
        "description": "Unlock Bitcoin hiring data! Instantly extract detailed listings from BitcoinerJobs, a leading board for Bitcoin and Lightning roles. Perfect for market research, recruitment, or job aggregators. Get structured, up-to-date global opportunities quickly and effortlessly. Built for Bitcoin hiring intel.",
        "version": "0.0",
        "x-build-id": "IZlHNjTcFUxQo2gzj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alichaudhry~bitcoinerjobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alichaudhry-bitcoinerjobs-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/alichaudhry~bitcoinerjobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alichaudhry-bitcoinerjobs-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/alichaudhry~bitcoinerjobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alichaudhry-bitcoinerjobs-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Bitcoiner Jobs page where crawling starts.",
                        "default": "https://bitcoinerjobs.com/"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Only include jobs matching at least one keyword.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locationFilters": {
                        "title": "Location Filters",
                        "type": "array",
                        "description": "Filter jobs by remote mode.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "remote-ok",
                                "remote-only"
                            ],
                            "enumTitles": [
                                "Remote OK",
                                "Remote Only"
                            ]
                        },
                        "default": []
                    },
                    "maxListings": {
                        "title": "Max Listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job listings to save.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration.",
                        "default": {
                            "useApifyProxy": true,
                            "checkAccess": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
