# bdjobs-job-apply

Adopt this skill: https://proskills.md/skills/other/sazidulalam47-bdjobs-job-apply-openclaw-skill

Page: https://proskills.md/skills/other/sazidulalam47-bdjobs-job-apply-openclaw-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 5552
upstream: https://github.com/sazidulalam47/bdjobs-job-apply-openclaw-skill/blob/HEAD/SKILL.md

```text
---
name: bdjobs-job-apply
description: BDJobs job search, matching, applying, undoing, and salary-update automation for OpenClaw. Use when the user wants to set up BDJobs credentials/preferences, search fresh non-applied jobs, inspect job details, auto-apply to matched jobs, cancel an application, or update expected salary.
---

# BDJobs Job Apply

Use this skill to help a user manage BDJobs job searching and applying without needing to know APIs or code.

## What this skill does

- Save resume text/LaTeX into `data/resume.md`
- Save credentials and preferences into `data/userDetails.json`
- Log in and save auth data into `data/loggedInData.json`
- Refresh applied jobs into `data/appliedJobIds.json`
- Keep a not-liked list in `data/notLikedJobIds.json`
- Search jobs and return raw job details for AI matching
- Auto-apply to matched jobs when asked
- Undo/cancel an applied job when asked
- Update expected salary for an already applied job

## Onboarding flow

When the user first sets up this skill, ask for these values in plain language:

1. BDJobs username
2. BDJobs password
3. Resume text or LaTeX
4. `everyDayApplyCount` (default: 2)
5. `everyDayCronTime` (default: `12:00 PM`)
6. `isFresher` (yes/no)
7. `Experience` in years
8. Preferred `jobLocation` (optional, leave blank for all)

Save them in:
- `data/userDetails.json`
- `data/resume.md`

If the user has extra search filters or matching rules, store them in `data/preferences.json`.

## Login flow

Before search/apply work, always ensure `data/loggedInData.json` exists.

If missing:
1. run `ChecKUsername`
2. take `guidId`
3. run `Login`
4. save `token`, `refreshToken`, `encryptId`, `decodeId`, and `guidId` to `data/loggedInData.json`

If login returns 401 at any point:
1. run `ChecKUsername` again
2. run `Login` again
3. overwrite `data/loggedInData.json`

## Search flow

When the user asks for fresh jobs:

1. Clear `data/suggestedJobs.json`
2. Run `scripts/bdjobs-refresh-applied.js` to update `data/appliedJobIds.json` from `GetApplyPositionInfoV1`
3. Run `scripts/bdjobs-fetch-jobs.js` with `--keyword`, `--isFresher`, `--postedWithin`, `--pg`, and `--jobLocation` to fetch raw job lists from `GetJobSearch`
4. Run `scripts/bdjobs-filter-jobs.js` to exclude already-applied and not-liked job IDs before `Job-Details`
5. For selected job IDs, run `scripts/bdjobs-job-details.js` to fetch full job details
6. Let AI compare the raw job details with `data/resume.md` and `data/preferences.json`
7. Run `scripts/bdjobs-rank-jobs.js` to save the top 5 matched jobs into `data/suggestedJobs.json`
8. Show the contents of `data/suggestedJobs.json` to the user

Recommended match threshold:
- show apply suggestions only if match is above 40%
- if the user asks for a looser list, show 30%+

AI matching details:
- Compare the raw job details with `data/resume.md` and `data/preferences.json`
- Judge fit from skills, education, age, experience, responsibilities, location, and preferences
- Output a suggested job list with match percentages

## Auto-apply flow

When the user asks to auto-apply:

1. Ensure login exists
2. Refresh applied jobs first
3. Search fresh jobs
4. Let AI score the raw job details against the resume and preferences
5. For each approved job:
   - call `JobApply`
   - read `MinimumSalary`
   - use it as `expectedSalary` in `JobApplyPost`
   - call `JobApplyPost`
   - if successful, always show `matchingScore`
   - if successful, add the job ID to `data/appliedJobIds.json`
   - save result in `data/lastApplyResult.json`
6. Send Telegram notification only after success

## Undo/cancel flow

When the user asks to undo an application:

1. Ensure login exists
2. Call `UndoJobApply` with job ID and `FormValue`
3. If successful, remove the job ID from `data/appliedJobIds.json`
4. Save result in `data/lastUndoResult.json`

## Expected salary update flow

When the user asks to update salary for an applied job:

1. Ensure login exists
2. Call `UpdateExpectedSalary`
3. Save result in `data/lastSalaryUpdateResult.json`

## Files used by this skill

Important files live inside this skill folder:
- `data/resume.md`
- `data/userDetails.json`
- `data/loggedInData.json`
- `data/appliedJobIds.json`
- `data/notLikedJobIds.json`
- `data/preferences.json`
- `data/suggestedJobs.json`
- `data/lastApplyResult.json`
- `data/lastUndoResult.json`
- `data/lastSalaryUpdateResult.json`

## Script entry points

Run scripts from the skill folder, not the workspace root:
- `scripts/init-job-profile.js`
- `scripts/bdjobs-login.js`
- `scripts/bdjobs-refresh-applied.js`
- `scripts/bdjobs-fetch-jobs.js`

`bdjobs-fetch-jobs.js` accepts:
- `--keyword=...`
- `--isFresher=true|false`
- `--postedWithin=...` (optional day count, any number)
- `--pg=...`
- `--jobLocation=...`
- `scripts/bdjobs-filter-jobs.js`
- `scripts/bdjobs-job-details.js` accepts `--jobId=...` or a positional job id
- `scripts/bdjobs-rank-jobs.js`
- `scripts/bdjobs-apply.js`
- `scripts/bdjobs-undo.js`
- `scripts/bdjobs-update-salary.js`

## Matching rules

Use the resume and these signals:
- Job title
- Company name
- Job description
- Education requirements
- Age requirement
- Experience requirement
- Additional job requirements
- Suggested skills
- Job location
- Job nature
- User preferences from `data/preferences.json`

## Helpful behavior

When presenting jobs to the user:
- keep language simple
- explain only what matters
- include the direct job link
- mention whether it looks worth applying

When the user wants automation, do the work directly with the scripts.
```

## File: README.md
upstream: https://github.com/sazidulalam47/bdjobs-job-apply-openclaw-skill/blob/HEAD/README.md

````text
# BDJobs Job Apply (OpenClaw Skill)

BDJobs Job Apply is an OpenClaw skill for automating the BDJobs workflow end to end: save a resume and profile, log in, refresh applied jobs, search fresh openings, rank the best matches, auto-apply, undo an application, and update expected salary.

## Clawhub

Project page: [clawhub.ai/sazidulalam47/bdjobs-job-apply](https://clawhub.ai/sazidulalam47/bdjobs-job-apply)

## What It Stores

The skill keeps its working data in the `data/` folder:

- `resume.md` - resume text or LaTeX
- `userDetails.json` - login and profile details
- `loggedInData.json` - active auth data from BDJobs
- `appliedJobIds.json` - job IDs already applied to
- `notLikedJobIds.json` - job IDs to exclude from future suggestions
- `preferences.json` - extra filters and matching preferences
- `rawJobs.json` - raw job search output
- `suggestedJobs.json` - ranked job suggestions
- `lastApplyResult.json` - most recent apply result
- `lastUndoResult.json` - most recent undo result
- `lastSalaryUpdateResult.json` - most recent salary update result

## Requirements

- Node.js installed locally
- BDJobs username and password
- A resume in plain text or LaTeX

## Quick Start

1. Create a profile from your resume:

```bash
node scripts/init-job-profile.js "your resume text or latex"
```

2. Save your BDJobs credentials and preferences in `data/userDetails.json` and `data/preferences.json`.

3. Log in and create `data/loggedInData.json`:

```bash
node scripts/bdjobs-login.js
```

4. Refresh applied jobs:

```bash
node scripts/bdjobs-refresh-applied.js
```

5. Search, filter, and rank fresh jobs.

## Common Workflows

### Search for Fresh Jobs

The typical search flow is:

1. Refresh applied jobs from BDJobs.
2. Fetch raw search results.
3. Remove already applied and not-liked jobs.
4. Fetch job details for the remaining candidates.
5. Rank the best matches and write `data/suggestedJobs.json`.

Useful commands:

```bash
node scripts/bdjobs-search.js --keywords=engineer,automation --pages=4 --isFresher=true --jobLocation="Dhaka"
node scripts/bdjobs-fetch-jobs.js --keyword=engineer --pages=2 --isFresher=true --jobLocation="Dhaka"
node scripts/bdjobs-filter-jobs.js < raw-jobs.json
node scripts/bdjobs-job-details.js --jobId=123456
node scripts/bdjobs-rank-jobs.js < jobs-with-details.json
```

### Apply to a Job

```bash
node scripts/bdjobs-apply.js --jobId=123456
```

If the apply succeeds, the job ID is added to `data/appliedJobIds.json` and the result is saved to `data/lastApplyResult.json`.

### Undo an Application

```bash
node scripts/bdjobs-undo.js --jobId=123456
```

If the cancellation succeeds, the job ID is removed from `data/appliedJobIds.json` and the result is saved to `data/lastUndoResult.json`.

### Update Expected Salary

```bash
node scripts/bdjobs-update-salary.js --jobId=123456 --newSalary=45000
```

The response is saved to `data/lastSalaryUpdateResult.json`.

## Script Reference

- `scripts/init-job-profile.js` - write resume text into `data/resume.md`
- `scripts/bdjobs-login.js` - run username check and login, then save auth data
- `scripts/bdjobs-refresh-applied.js` - refresh `data/appliedJobIds.json`
- `scripts/bdjobs-applied.js` - print applied jobs and refresh `data/appliedJobIds.json`
- `scripts/bdjobs-search.js` - fetch raw job search results using saved profile data
- `scripts/bdjobs-fetch-jobs.js` - fetch raw jobs for a single keyword or search term
- `scripts/bdjobs-filter-jobs.js` - remove already-applied jobs from a JSON stream on stdin
- `scripts/bdjobs-job-details.js` - fetch full job details for one job ID
- `scripts/bdjobs-rank-jobs.js` - rank jobs and write the top five suggestions
- `scripts/bdjobs-apply.js` - apply to a job by ID
- `scripts/bdjobs-undo.js` - cancel an application by ID
- `scripts/bdjobs-update-salary.js` - update expected salary for an applied job
- `scripts/bdjobs-daily-run.js` - placeholder for a cron-based daily runner

## Matching Rules

The ranking flow compares the resume and preferences against:

- job title
- company name
- job description
- education requirements
- age requirement
- experience requirement
- additional requirements
- suggested skills
- job location
- job nature

## API Notes

The repository also includes a compact API reference in `references/api.md` for the BDJobs endpoints used by the scripts.

## Expected Workflow

For OpenClaw automation, the intended order is:

1. Initialize the profile.
2. Log in.
3. Refresh applied jobs.
4. Search fresh jobs.
5. Rank the best matches.
6. Apply only to the strongest candidates.

This keeps the suggestions aligned with the resume, avoids duplicates, and preserves a clear local record of each action.
````
