Service Update
isecjobs.com has shut down

isecjobs.com shut down on June 30, 2026 due to lower-than-expected demand.
To find future jobs and more please continue on foorilla.com.
For builders: API access to the hiring feed is available with an active foo🦍 PRO+ subscription.
How We Built It
Import script used for the feed

For transparency, here is the standalone Python importer that mirrors the original isecjobs.com ingestion flow: API-key auth, topic plus keyword passes, pagination, 429 retry/backoff, expired-job filtering, deduplication, and JSON output.
You can run this directly, adapt it to your stack, or use it as a baseline for your own scheduled importer.
foorilla API
#!/usr/bin/env python3
"""Standalone importer example for the foorilla hiring job feed.

This script mirrors the core isecjobs.com import strategy in a simple form:
- API key auth via the `Api-Key` header
- topic pass + keyword passes
- pagination
- HTTP 429 retry with Retry-After handling
- skip expired jobs and deduplicate by `id`
- checkpoint JSON output after each API request using a disk cache to keep memory flat
- export final dataset as JSON

Requirements:
- Active foo🦍 PRO+ subscription
- `FOO_API_KEY` in your environment or `--api-key`
"""

from __future__ import annotations

import argparse
import datetime as dt
import json
import os
import sqlite3
import tempfile
import time
from typing import Dict, Iterable, List, Optional, Sequence

import requests


API_BASE = "https://foorilla.com/api/v1/"

FOO_API_TOPICS = [102, 58, 26, 40, 27, 83]
FOO_API_TOPIC_MAIN = 102
FOO_API_TITLE_KEYWORDS = [
    "app sec",
    "appsec",
    "blue team",
    "cloud sec",
    "cloud siem",
    "cloudsec",
    "cryptogra",
    "cryptolog",
    "cyber sec",
    "cybersec",
    "cybersecur",
    "detection",
    "devsecops",
    "dfir",
    "digital forens",
    "edr",
    "endpoint secur",
    "ethical hack",
    "exploit",
    "firewall",
    "grc",
    "iam",
    "iam eng",
    "iam sec",
    "incident resp",
    "information sec",
    "infosec",
    "it secur",
    "key manag",
    "malware",
    "malware ana",
    "mitre att",
    "netsec",
    "network sec",
    "nist",
    "owasp",
    "pen test",
    "pentest",
    "penetration test",
    "privacy",
    "data protect",
    "purple team",
    "red team",
    "reverse eng",
    "risk manag",
    "secops",
    "secure cod",
    "security ana",
    "security arch",
    "security autom",
    "security compli",
    "security dev",
    "security eng",
    "security oper",
    "security res",
    "secret manag",
    "siem",
    "soc ana",
    "soc eng",
    "soc 2",
    "soar",
    "splunk",
    "sdlc secur",
    "threat detect",
    "threat hunt",
    "threat intel",
    "threat res",
    "vulnerab",
    "vulnerab manag",
    "vuln manag",
    "zero trust",
]


def parse_csv_list(raw: str) -> List[str]:
    return [item.strip() for item in raw.split(",") if item.strip()]


def parse_csv_ints(raw: str) -> List[int]:
    return [int(item.strip()) for item in raw.split(",") if item.strip()]


def fetch_page_with_retry(
    session: requests.Session,
    url: str,
    params: Dict[str, object],
    max_retries: int = 3,
) -> requests.Response:
    retries = 0
    while True:
        response = session.get(url, params=params, timeout=30)
        if response.status_code != 429:
            return response

        if retries >= max_retries:
            return response

        retry_after = response.headers.get("Retry-After")
        wait_seconds: Optional[int] = None
        if retry_after:
            try:
                wait_seconds = max(1, int(float(retry_after)))
            except (TypeError, ValueError):
                wait_seconds = None
        if wait_seconds is None:
            wait_seconds = min(60, 2 ** (retries + 1))

        print(f"Rate limited (HTTP 429). Retrying in {wait_seconds}s...")
        time.sleep(wait_seconds)
        retries += 1


def iter_job_pages_for_batch(
    session: requests.Session,
    published_after: str,
    topics: Sequence[int],
    keyword: Optional[str],
    page_size: int = 500,
) -> Iterable[tuple[List[dict], int, int]]:
    page = 1
    while True:
        params: Dict[str, object] = {
            "page": page,
            "page_size": page_size,
            "published_after": published_after,
        }

        if keyword:
            params["title"] = keyword
        elif topics:
            params["topic"] = list(topics)

        response = fetch_page_with_retry(
            session,
            f"{API_BASE}hiring/job/",
            params=params,
        )

        # Conservative pacing to stay within account limits.
        time.sleep(0.25)

        if response.status_code != 200:
            raise RuntimeError(
                f"Failed to fetch hiring/job (HTTP {response.status_code}) for params={params}"
            )

        payload = response.json()
        results = payload.get("results", [])
        total_count = int(payload.get("count", 0))
        yield results, page, total_count

        if page * page_size >= total_count:
            break
        page += 1


def init_job_cache(conn: sqlite3.Connection) -> None:
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS jobs (
            id INTEGER PRIMARY KEY,
            published TEXT,
            payload TEXT NOT NULL
        )
        """
    )
    conn.commit()


def write_snapshot_json(
    conn: sqlite3.Connection,
    output_path: str,
    published_days: int,
    topics: Sequence[int],
    keywords: Sequence[str],
    skipped_expired: int,
) -> int:
    count_row = conn.execute("SELECT COUNT(*) FROM jobs").fetchone()
    job_count = int(count_row[0]) if count_row else 0

    with open(output_path, "w", encoding="utf-8") as handle:
        handle.write("{\n")
        handle.write('  "source": "foorilla hiring/job",\n')
        handle.write(
            f'  "generated_at": {json.dumps(dt.datetime.now(dt.timezone.utc).isoformat(), ensure_ascii=False)},\n'
        )
        handle.write(f'  "published_days": {published_days},\n')
        handle.write(f'  "topics": {json.dumps(list(topics), ensure_ascii=False)},\n')
        handle.write(f'  "keywords": {json.dumps(list(keywords), ensure_ascii=False)},\n')
        handle.write(f'  "skipped_expired": {skipped_expired},\n')
        handle.write(f'  "count": {job_count},\n')
        handle.write('  "jobs": [\n')

        first = True
        cursor = conn.execute(
            "SELECT payload FROM jobs ORDER BY COALESCE(published, '') DESC, id DESC"
        )
        for row in cursor:
            payload = row[0]
            formatted_job = json.dumps(json.loads(payload), indent=4, ensure_ascii=False)
            indented_job = "\n".join(f"    {line}" for line in formatted_job.splitlines())
            if not first:
                handle.write(",\n")
            handle.write(indented_job)
            first = False

        if not first:
            handle.write("\n")
        handle.write("  ]\n")
        handle.write("}\n")

    return job_count


def import_jobs(
    api_key: str,
    output_path: str,
    published_days: int,
    topics: Sequence[int],
    keywords: Sequence[str],
) -> None:
    skipped_expired = 0
    total_seen = 0
    snapshot_count = 0
    published_after = (dt.date.today() - dt.timedelta(days=published_days)).isoformat()
    keyword_passes: List[Optional[str]] = [None, *keywords] if keywords else [None]

    cache_fd, cache_path = tempfile.mkstemp(prefix="importjobs_", suffix=".sqlite3")
    os.close(cache_fd)

    try:
        with sqlite3.connect(cache_path) as conn:
            init_job_cache(conn)

            with requests.Session() as session:
                session.headers.update({"Api-Key": api_key})

                for keyword in keyword_passes:
                    label = keyword if keyword else "(all/topics pass)"
                    batch_added = 0
                    batch_expired = 0

                    for results, page, total_count in iter_job_pages_for_batch(
                        session=session,
                        published_after=published_after,
                        topics=topics,
                        keyword=keyword,
                    ):
                        for job in results:
                            if job.get("expired"):
                                skipped_expired += 1
                                batch_expired += 1
                                continue

                            raw_job_id = job.get("id")
                            if raw_job_id is None:
                                continue

                            try:
                                job_id = int(raw_job_id)
                            except (TypeError, ValueError):
                                continue

                            payload = json.dumps(job, ensure_ascii=False, separators=(",", ":"))
                            cursor = conn.execute(
                                "INSERT OR IGNORE INTO jobs (id, published, payload) VALUES (?, ?, ?)",
                                (job_id, job.get("published") or "", payload),
                            )
                            if cursor.rowcount:
                                total_seen += 1
                                batch_added += 1

                        print(
                            f"Processed page {page} [title={label}] | total_seen={total_seen} | "
                            f"api_count={total_count}"
                        )

                        conn.commit()
                        snapshot_count = write_snapshot_json(
                            conn=conn,
                            output_path=output_path,
                            published_days=published_days,
                            topics=topics,
                            keywords=keywords,
                            skipped_expired=skipped_expired,
                        )
                        print(
                            f"Checkpoint written after request [title={label} page={page}] | "
                            f"batch_added={batch_added} | skipped_expired_batch={batch_expired} | "
                            f"total_seen={snapshot_count}"
                        )

                        # Drop per-request references so memory usage stays flat.
                        results = []

        print(f"Wrote {snapshot_count} jobs to {output_path}")
    finally:
        if os.path.exists(cache_path):
            os.remove(cache_path)


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Export infosec/privacy jobs from the foorilla API to JSON."
    )
    parser.add_argument(
        "--api-key",
        default=os.getenv("FOO_API_KEY", ""),
        help="foorilla API key (or set FOO_API_KEY).",
    )
    parser.add_argument(
        "--output",
        default="jobs.json",
        help="Path to output JSON file (default: jobs.json).",
    )
    parser.add_argument(
        "--published-days",
        type=int,
        default=60,
        help="Only fetch jobs newer than N days (default: 60).",
    )
    parser.add_argument(
        "--topics",
        default=",".join(str(topic) for topic in FOO_API_TOPICS),
        help="Comma-separated topic IDs for the base pass (example: 12,98).",
    )
    parser.add_argument(
        "--keywords",
        default=",".join(FOO_API_TITLE_KEYWORDS),
        help="Comma-separated title keywords for additional passes.",
    )
    return parser


def main() -> None:
    args = build_parser().parse_args()
    api_key = args.api_key.strip()
    if not api_key:
        raise SystemExit("Missing API key. Set FOO_API_KEY or pass --api-key.")

    topics = parse_csv_ints(args.topics) if args.topics else []
    keywords = parse_csv_list(args.keywords) if args.keywords else []

    import_jobs(
        api_key=api_key,
        output_path=args.output,
        published_days=args.published_days,
        topics=topics,
        keywords=keywords,
    )


if __name__ == "__main__":
    main()
Attribution note: data from foorilla API is licensed under CC BY-SA 4.0.