Using the Jobstreet API without getting blocked

Building against a Jobstreet API rarely fails because of parsing. The harder problem is staying in: requests leave successfully, then responses return empty, truncated, or replaced by a challenge page the parser cannot handle.

Here is what our own Jobstreet Actor handles, what a run costs, and where it stops.

Doing it yourself

The DIY route makes sense when you need one snapshot or when a broken run costs nothing. The specifics below come directly from what our own scraper has to handle.

The front door. A plain HTTP request to Jobstreet does not return a page. Measured on 2026-08-22 (3 attempts, all refused), it returned 403 behind Cloudflare, actively challenging. Your scraper must clear that barrier before parsing a single field.

Rate limits. Push hard enough and Jobstreet returns 429. Backoff is mandatory; without it, the run becomes a queue of failures.

Proxies. Runs use rotating proxies. A single IP creates a trivially detectable pattern, and proxies are usually the largest cost line, well above compute.

Pagination. Listings are paged. The stop condition needs more care than "until a page comes back empty" because an empty page can also signal a soft block.

Silent breakage. Jobstreet changes its markup without announcing it. Extraction then fails quietly, producing empty fields instead of an error. Detecting that drift is a separate piece of work.

Deduplication. Re-running produces the same records. Hashing every record and storing the hashes prevents each run from re-processing everything.

The real cost is upkeep. The first version takes an afternoon to write. Keeping it working takes an hour every few weeks, forever. Failures stay silent: you discover them when a report is empty, not when the scraper errors.

Here is a measured run, not an estimate:

• 25 records in 28.0 seconds
• cost: $0.00155 — about $0.06 per 1,000 records

The shortcut

If you do not want to own that work, one call returns the same result:

```bash curl -X POST "https://api.apify.com/v2/acts/blackfalcondata~jobstreet-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \ -H 'Content-Type: application/json' \ -d '{"query": "..."}' ```

Or use Python:

```python from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN") run = client.actor("blackfalcondata~jobstreet-scraper").call(run_input={"query": "..."})

for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ```

What comes back

Every row contains 73 fields, grouped into categories such as:

• company — company, companyUrl, companyIndustry, companySize, companyWebsite, companyDescription, +6 more
• location — location, locationCountry, locationState, locationSuburb, locationPostcode
• salary — salaryText, salaryMin, salaryMax, salaryCurrency, salaryType

What people use it for

• Benchmarking. Pricing and salary fields support comparisons across the whole set instead of an eyeballed page of results.
• Reputation monitoring. Ratings and review text reveal movement over time that a single page view cannot show.
• Lead lists. Company-level fields let you isolate the relevant segment before anyone opens a CRM.
• Change detection. Timestamps make it possible to diff runs and act on new records rather than re-reading everything.
• Geographic analysis. Location fields enable market-by-market comparisons without a separate data source.

Limits

Nothing here bypasses a Jobstreet login. Whoever writes the scraper, it can access public pages only.

A scraper that works today may not work in six weeks. Expect to touch it whenever Jobstreet ships a redesign—and expect some delay before you notice. Extraction fails quietly, returning empty fields rather than errors. Budget an hour every few weeks, not a fix-and-forget afternoon.

Proxy costs also rise with volume. They are the line item people often omit when estimating the DIY route. For anything beyond a small sample, you need proxies: a single origin IP is the easiest target to rate-limit, and residential addresses are treated differently from datacentre ones.

The browser-versus-client difference explains many 403s. A plain request to Jobstreet from our probe on 2026-08-22 was answered by cloudflare, actively challenging — every attempt was refused. A browser passes because it carries a TLS fingerprint, a cookie and a header set that a bare HTTP client does not.

Reading publicly visible pages is generally treated differently from accessing data behind a login, and courts in the US have repeatedly declined to treat public scraping as unauthorised access. That is not legal advice, and a site's terms of service are a separate question from the law. Anything behind a login is out of scope either way.

Building it yourself is cheaper only if your time is free. The measured run below cost $0.00155 for 25 records; the equivalent DIY cost is proxy spend plus the maintenance hour, and the maintenance hour recurs.

Try it

If you would rather not own the upkeep, a working Jobstreet API you can call today already handles everything above. New accounts get $5 of free platform credit each month, which covers a real run of this size several times over.

Disclosure: we build and maintain this Actor, and the link above is an affiliate link.

Further reading

• hiQ Labs v. LinkedIn — the appeals decision on scraping public pages
• Apify's API reference — the endpoints used above
• dataset storage — how results are stored and exported
• proxy documentation — what the proxy layer costs and offers
• Naukri API — another scraper we build and document
• our Seek API guide — another scraper we build and document
• the Wellfound API field reference — another scraper we build and document

We also publish our write-up on the Jobstreet API on blackfalcondata.com — the request, the response, and what a run costs.