Best Free Jobs and Tech News APIs for Developers (Build Real Career Tools for $0)

The Job Board Trap: Why Commercial Portals Fail Junior Developers

If you have spent the last few months submitting job applications on generic employment portals, you already know the sinking feeling. You upload your resume, fill out forty repetitive input fields, solve three reCAPTCHA puzzles, and click submit. Then: absolute silence. Weeks pass without a single automated rejection email, let alone a screening call.

Here is what happens behind the scenes on commercial job boards: the majority of postings are stale, scraped from other websites months ago, or kept active to collect resume databases. Other listings are buried behind expensive subscription paywalls that demand hundreds of dollars every month just to see who posted the opening.

When you are sitting in a Tier-3 college hostel or grinding after hours on an 8GB RAM laptop to escape a 3.5 LPA mass-recruiter service bond, you cannot afford paid subscriptions. You have a zero-rupee budget and limited hours every evening. You cannot waste your energy throwing resumes into digital black holes.

Smart developers solve this problem by taking control of their own pipeline: they build their own job discovery radar. Instead of relying on crowded job boards, you can pull hiring announcements straight from the source: direct founder posts on HackerNews, verified remote roles from Remotive, and global salary indices from Adzuna.

Even better: your custom job radar becomes the centerpiece of your engineering portfolio. When a technical interviewer asks what you built, you do not show them another generic Todo list. You open your browser and demonstrate a live, production-grade career aggregator that filters remote roles by tech stack, parses discussion trees, and tracks real-world engineering salaries. If you want to know why interviewers ignore standard bootcamp apps, read our breakdown on why you should stop building todo apps and use free public APIs.

Let us explore the five best free jobs and tech news APIs you can use right now with zero budget and zero credit cards.

1. HackerNews Firebase REST API: 100% Keyless Job and Discussion Trees

HackerNews, operated by Y Combinator, is the heartbeat of the global startup ecosystem. Every month, founders and engineering leads post hundreds of direct hiring notices in dedicated threads like "Ask HN: Who is hiring?". In addition, Y Combinator companies post official openings in the HN jobs section.

Google Firebase hosts the official HackerNews API as a completely open, keyless REST endpoint. You do not need an account, you do not need an API secret, and CORS is natively enabled across all modern web browsers.

Key Endpoints

• Job Stories Endpoint: https://hacker-news.firebaseio.com/v0/jobstories.json returns an array of up to 200 of the latest official YC job posting IDs.
• Top and New Stories: https://hacker-news.firebaseio.com/v0/topstories.json and /newstories.json return up to 500 current story IDs.
• Item Details: https://hacker-news.firebaseio.com/v0/item/{id}.json retrieves complete metadata for any story, job posting, or comment.

The Recursive Comment Tree Structure

Unlike standard flat REST responses, HackerNews models discussions as a recursive tree. Each story or comment object contains an array named kids holding the IDs of its direct children. For example, in the monthly "Who is hiring?" thread, the root story contains hundreds of child IDs in its kids property. Each child is a direct top-level comment from a hiring manager detailing tech requirements, location preferences, and application email addresses.

// Fetching the latest HackerNews job story IDs and resolving details
async function fetchLatestHnJobs(limit = 5) {
  const listUrl = 'https://hacker-news.firebaseio.com/v0/jobstories.json';
  const listRes = await fetch(listUrl);
  const storyIds = await listRes.json();

  // Parallel fetch for the first few job item records
  const targetIds = storyIds.slice(0, limit);
  const jobs = await Promise.all(
    targetIds.map(async (id) => {
      const itemUrl = `https://hacker-news.firebaseio.com/v0/item/${id}.json`;
      const itemRes = await fetch(itemUrl);
      return itemRes.json();
    })
  );

  return jobs.map(job => ({
    id: job.id,
    title: job.title,
    url: job.url || `https://news.ycombinator.com/item?id=${job.id}`,
    time: new Date(job.time * 1000).toLocaleDateString(),
    by: job.by
  }));
}

Because every item lookup requires an individual network request, client applications should fetch item trees in controlled batches and cache resolved records locally.

2. Dev.to (Forem) API: 100% Keyless Developer Articles and Tech Trends

Keeping up with changing industry patterns is critical when preparing for job interviews. Dev.to, built on the open-source Forem software, hosts articles written by working software developers worldwide. Their REST API allows you to pull articles filtered by technical tags, publication dates, and community engagement scores without requiring an API key.

Core Features and Endpoints

• Tag-Based Filtering: Fetch articles focused on your specific stack using /api/articles?tag=react, tag=typescript, tag=nodejs, or tag=career.
• Engagement Metrics: Inspect positive_reactions_count, comments_count, and reading_time_minutes to surface the most valuable discussions.
• Zero-Auth Read Access: GET endpoints are completely public. You only need an API key if you want to publish new articles from your code.

Sample Query: Fetching Trending Frontend Architecture Articles

// Query Dev.to for high-engagement articles on React and Career
async function fetchTrendingTechArticles(tag = 'react', minReactions = 20) {
  const url = new URL('https://dev.to/api/articles');
  url.searchParams.set('tag', tag);
  url.searchParams.set('top', '7'); // Top articles in the last 7 days
  url.searchParams.set('per_page', '10');

  const res = await fetch(url.toString());
  if (!res.ok) {
    throw new Error('Dev.to API error: ' + res.status);
  }

  const articles = await res.json();
  return articles
    .filter(a => a.positive_reactions_count >= minReactions)
    .map(a => ({
      id: a.id,
      title: a.title,
      description: a.description,
      url: a.url,
      readingTime: a.reading_time_minutes,
      reactions: a.positive_reactions_count,
      author: a.user.name,
      tags: a.tag_list
    }));
}

If you want to discover more public endpoints that do not require any signup tokens or account registrations, browse our complete guide to free public APIs without API keys.

3. Remotive Jobs API: 100% Keyless Remote Developer Roles

Remotive is one of the premier remote work communities on the web. Their editorial team reviews and categorizes hundreds of legitimate remote jobs every week. Unlike corporate job platforms that lock their database behind closed partnerships, Remotive provides a clean, keyless public JSON endpoint.

Why Remotive Stands Out for Portfolio Projects

• Explicit Salary Transparency: Many Remotive job postings include actual salary numbers (e.g., "$100,000 - $130,000 USD"), allowing you to display salary badges directly in your UI.
• Location Requirement Clarity: The candidate_required_location field clarifies whether a remote role accepts applicants worldwide or restricts hiring to specific regions (like "USA Only" or "Europe Only"). This helps developers in India, Southeast Asia, and Latin America filter out geographically restricted listings immediately.
• Rich Company Metadata: Every record includes the hiring company name, company logo URL, publication timestamp, and direct application URL.
• Category and Keyword Filters: Filter specifically for software-dev, devops, qa, or data.

// Fetching remote software development openings worldwide
async function fetchWorldwideRemoteJobs(techKeyword = 'React') {
  const url = new URL('https://remotive.com/api/remote-jobs');
  url.searchParams.set('category', 'software-dev');
  url.searchParams.set('search', techKeyword);
  url.searchParams.set('limit', '25');

  const res = await fetch(url.toString());
  if (!res.ok) {
    throw new Error('Remotive API request failed: ' + res.status);
  }

  const data = await res.json();
  const jobs = data.jobs || [];

  // Filter for worldwide roles or roles open to any location
  return jobs.filter(job => {
    const loc = (job.candidate_required_location || '').toLowerCase();
    return loc.includes('worldwide') || loc.includes('anywhere') || loc === '';
  }).map(job => ({
    id: job.id,
    title: job.title,
    company: job.company_name,
    logo: job.company_logo,
    location: job.candidate_required_location || 'Worldwide',
    salary: job.salary || 'Competitive',
    tags: job.tags || [],
    applyUrl: job.url,
    publishedAt: job.publication_date
  }));
}

4. Adzuna Job Search API: Global Postings and Predictive Salary Modeling

Adzuna indexes millions of active job advertisements across 16 countries, including the United States, United Kingdom, India, Canada, Germany, and Australia. If you want your application to provide local market data or compare engineering compensation across different countries, Adzuna is the premier tool.

Key Architectural Strengths

• Predictive Salary Engine: When employers omit compensation details from a listing, Adzuna calculates an estimated salary range using statistical models trained on comparable local positions. The API returns fields like salary_min, salary_max, and salary_is_predicted.
• Regional Country Routing: The country code is part of the URL path (e.g., /v1/api/jobs/in/search/1 for India, /us/ for the United States, /gb/ for the United Kingdom).
• Contract and Employment Type Filters: Filter postings by full-time, part-time, contract, or permanent status.

Authentication and Developer Tier

Adzuna requires an app_id and app_key passed as query parameters. Signing up on the Adzuna developer portal takes less than two minutes and requires no credit card. Their free developer tier provides between 250 and 1,000 free requests per month, which is ideal for periodic background syncing and personal demonstration projects.

// Querying Adzuna for Bangalore-based full-stack developer roles
async function searchAdzunaJobs(appId, appKey, query = 'Full Stack Developer', country = 'in') {
  const url = new URL(`https://api.adzuna.com/v1/api/jobs/${country}/search/1`);
  url.searchParams.set('app_id', appId);
  url.searchParams.set('app_key', appKey);
  url.searchParams.set('what', query);
  url.searchParams.set('results_per_page', '10');
  url.searchParams.set('content-type', 'application/json');

  const res = await fetch(url.toString());
  if (!res.ok) {
    throw new Error('Adzuna API call failed: ' + res.status);
  }

  const data = await res.json();
  return (data.results || []).map(item => ({
    id: item.id,
    title: item.title,
    company: item.company?.display_name || 'Confidential',
    location: item.location?.display_name || 'Remote',
    salaryMin: item.salary_min || null,
    salaryMax: item.salary_max || null,
    isPredictedSalary: item.salary_is_predicted === 1,
    redirectUrl: item.redirect_url,
    created: item.created
  }));
}

5. Currents API and NewsData.io: Real-Time Global Tech Headlines

Writing clean syntax is only half the job: great software engineers understand where the tech industry is heading. When walking into a technical interview, knowing recent developments (like major security vulnerabilities, cloud outages, or AI model releases) gives you talking points that immediately impress engineering managers.

Two dependable free APIs deliver real-time technology news headlines without requiring corporate contracts:

Currents API

Currents API indexes thousands of news sources worldwide in real time. It offers a free developer tier providing 600 requests per day with zero credit card requirements. You can filter news by category (category=technology), language, or specific keywords (such as "TypeScript", "PostgreSQL", or "Kubernetes").

NewsData.io

NewsData.io provides an alternative global news feed with support for domain filtering and multi-language news queries. Their free tier grants 200 request credits per day, returning clean JSON containing article titles, summaries, original source links, and publication timestamps.

// Fetching latest tech headlines using Currents API
async function fetchLatestTechHeadlines(apiKey, keyword = 'software engineering') {
  const url = new URL('https://api.currentsapi.services/v1/search');
  url.searchParams.set('apiKey', apiKey);
  url.searchParams.set('category', 'technology');
  url.searchParams.set('keywords', keyword);
  url.searchParams.set('language', 'en');

  const res = await fetch(url.toString());
  if (!res.ok) {
    throw new Error('Currents API error: ' + res.status);
  }

  const data = await res.json();
  return (data.news || []).slice(0, 8).map(article => ({
    id: article.id,
    title: article.title,
    description: article.description,
    url: article.url,
    published: article.published,
    author: article.author || 'Tech Reporter'
  }));
}

Feature Comparison: The Free Jobs and Tech News API Stack

Here is how the five career and news APIs compare across authentication mechanisms, free allowances, cross-origin browser compatibility, and ideal project use cases:

Production Project Blueprint: "DevPulse: Real-Time Developer Radar & Remote Job Aggregator"

To turn these open endpoints into an interview-winning project, let us design a complete, production-grade application: DevPulse. Instead of building another isolated job viewer, DevPulse combines remote job discovery, tech news tracking, and community discussion analysis into a single unified developer dashboard.

System Architecture

1. Parallel Multi-Source Ingestion: On dashboard startup, the client dispatches parallel requests to Remotive (for verified remote jobs) and HackerNews (for direct founder hiring notices) using Promise.allSettled(). If one upstream service experiences downtime, the other feed continues rendering smoothly without crashing the page.
2. In-Memory TTL Caching: Mobile users on Tier-3 college cellular networks cannot afford to re-download the same API payloads every time they switch tabs. DevPulse wraps network calls in a lightweight Time-To-Live (TTL) cache. Lookups remain valid in memory for 60 seconds before triggering a fresh network fetch.
3. Salary Normalization and Filtering: The aggregator parses string salary representations from Remotive (such as "$110k - $140k USD") into structured numerical values. Users can set a minimum salary slider to eliminate unpaid internships or non-competitive listings.
4. HackerNews Tree Traversal: DevPulse reads the monthly "Who is hiring?" thread and traverses its top-level comment tree. It scans comment bodies for developer keywords (like "React", "Go", "Python", "Postgres") and matches candidate profiles to direct hiring manager contacts.
5. Interview Pulse Widget: The sidebar displays top trending architectural articles from Dev.to and breaking industry news from Currents API, giving you a sharp briefing before your technical interviews.

Production TypeScript Code: Resilient Career Radar Client Module

Here is a complete, copy-pasteable TypeScript module that implements in-memory caching, HackerNews tree inspection, Remotive job filtering, and Dev.to article aggregation with clean error handling:

/**
 * DevPulse Career Radar & Job Aggregator Client
 * Production-ready TypeScript module with in-memory TTL caching and error handling
 */

export interface RemoteJob {
  id: number | string;
  source: 'remotive' | 'hackernews';
  title: string;
  company: string;
  location: string;
  salary: string;
  minSalaryUsd?: number;
  url: string;
  publishedAt: string;
  tags: string[];
}

export interface TechArticle {
  id: number;
  title: string;
  description: string;
  url: string;
  readingTimeMin: number;
  reactions: number;
  author: string;
  tags: string[];
}

interface CacheEntry<T> {
  data: T;
  expiresAt: number;
}

/**
 * Lightweight in-memory TTL cache to prevent redundant network calls
 */
class MemoryCache {
  private store = new Map<string, CacheEntry<any>>();

  get<T>(key: string): T | null {
    const entry = this.store.get(key);
    if (!entry) return null;
    if (Date.now() > entry.expiresAt) {
      this.store.delete(key);
      return null;
    }
    return entry.data as T;
  }

  set<T>(key: string, data: T, ttlSeconds: number): void {
    this.store.set(key, {
      data,
      expiresAt: Date.now() + ttlSeconds * 1000
    });
  }

  clear(): void {
    this.store.clear();
  }
}

export const pulseCache = new MemoryCache();

/**
 * Helper to parse salary text into an approximate minimum USD value
 */
export function extractMinSalary(salaryText: string): number | undefined {
  if (!salaryText) return undefined;
  // Match patterns like "$120k", "$120,000", "120k"
  const match = salaryText.match(/\$?(\d{2,3})(?:,000|k)/i);
  if (match && match[1]) {
    return parseInt(match[1], 10) * 1000;
  }
  return undefined;
}

/**
 * 1. Remotive API: Fetch remote developer jobs with keyword filtering and caching
 */
export async function fetchRemotiveJobs(
  keyword: string = 'react',
  onlyWorldwide: boolean = true,
  timeoutMs: number = 8000
): Promise<RemoteJob[]> {
  const cacheKey = `remotive_${keyword}_${onlyWorldwide}`;
  const cached = pulseCache.get<RemoteJob[]>(cacheKey);
  if (cached) return cached;

  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const url = new URL('https://remotive.com/api/remote-jobs');
    url.searchParams.set('category', 'software-dev');
    url.searchParams.set('search', keyword);
    url.searchParams.set('limit', '30');

    const res = await fetch(url.toString(), { signal: controller.signal });
    if (!res.ok) {
      throw new Error(`Remotive API responded with HTTP ${res.status}`);
    }

    const payload = await res.json();
    const rawJobs = payload.jobs || [];

    const normalizedJobs: RemoteJob[] = rawJobs
      .filter((j: any) => {
        if (!onlyWorldwide) return true;
        const loc = (j.candidate_required_location || '').toLowerCase();
        return loc.includes('worldwide') || loc.includes('anywhere') || loc === '';
      })
      .map((j: any) => ({
        id: j.id,
        source: 'remotive' as const,
        title: j.title,
        company: j.company_name,
        location: j.candidate_required_location || 'Worldwide Remote',
        salary: j.salary || 'Salary Not Disclosed',
        minSalaryUsd: extractMinSalary(j.salary || ''),
        url: j.url,
        publishedAt: j.publication_date,
        tags: j.tags || []
      }));

    pulseCache.set(cacheKey, normalizedJobs, 120); // 2 minute cache
    return normalizedJobs;
  } catch (err: any) {
    if (err.name === 'AbortError') {
      console.warn('Remotive API request timed out.');
    } else {
      console.error('Failed to fetch Remotive jobs:', err.message);
    }
    return [];
  } finally {
    clearTimeout(timer);
  }
}

/**
 * 2. HackerNews Firebase REST API: Query direct YC hiring posts
 */
export async function fetchHnJobStories(limit: number = 10): Promise<RemoteJob[]> {
  const cacheKey = `hn_jobstories_${limit}`;
  const cached = pulseCache.get<RemoteJob[]>(cacheKey);
  if (cached) return cached;

  try {
    const listRes = await fetch('https://hacker-news.firebaseio.com/v0/jobstories.json');
    if (!listRes.ok) throw new Error(`HN job list failed: HTTP ${listRes.status}`);

    const storyIds: number[] = await listRes.json();
    const targetIds = (storyIds || []).slice(0, limit);

    const jobResults = await Promise.allSettled(
      targetIds.map(async (id) => {
        const itemRes = await fetch(`https://hacker-news.firebaseio.com/v0/item/${id}.json`);
        if (!itemRes.ok) throw new Error(`Item ${id} fetch error`);
        return itemRes.json();
      })
    );

    const jobs: RemoteJob[] = jobResults
      .filter((r): r is PromiseFulfilledResult<any> => r.status === 'fulfilled' && r.value)
      .map((r) => {
        const item = r.value;
        return {
          id: item.id,
          source: 'hackernews' as const,
          title: item.title || 'Engineering Role at YC Startup',
          company: item.by || 'YC Company',
          location: 'Remote / Hybrid',
          salary: 'Competitive Equity & Salary',
          url: item.url || `https://news.ycombinator.com/item?id=${item.id}`,
          publishedAt: new Date(item.time * 1000).toISOString(),
          tags: ['YC', 'Startup']
        };
      });

    pulseCache.set(cacheKey, jobs, 180); // 3 minute cache
    return jobs;
  } catch (err: any) {
    console.error('Failed to fetch HackerNews jobs:', err.message);
    return [];
  }
}

/**
 * 3. Dev.to API: Pull trending tech articles for interview context
 */
export async function fetchDevToArticles(
  tag: string = 'react',
  minReactions: number = 15
): Promise<TechArticle[]> {
  const cacheKey = `devto_${tag}_${minReactions}`;
  const cached = pulseCache.get<TechArticle[]>(cacheKey);
  if (cached) return cached;

  try {
    const url = new URL('https://dev.to/api/articles');
    url.searchParams.set('tag', tag);
    url.searchParams.set('top', '7');
    url.searchParams.set('per_page', '8');

    const res = await fetch(url.toString());
    if (!res.ok) throw new Error(`Dev.to returned HTTP ${res.status}`);

    const articles = await res.json();
    const results: TechArticle[] = (articles || [])
      .filter((a: any) => a.positive_reactions_count >= minReactions)
      .map((a: any) => ({
        id: a.id,
        title: a.title,
        description: a.description,
        url: a.url,
        readingTimeMin: a.reading_time_minutes,
        reactions: a.positive_reactions_count,
        author: a.user?.name || 'Developer',
        tags: a.tag_list || []
      }));

    pulseCache.set(cacheKey, results, 300); // 5 minute cache
    return results;
  } catch (err: any) {
    console.error('Failed to fetch Dev.to articles:', err.message);
    return [];
  }
}

/**
 * 4. Unified Aggregator: Fetch jobs from both Remotive and HackerNews in parallel
 */
export async function getAggregatedDeveloperRadar(techKeyword: string = 'react') {
  const [remotiveJobs, hnJobs, articles] = await Promise.all([
    fetchRemotiveJobs(techKeyword, true),
    fetchHnJobStories(8),
    fetchDevToArticles(techKeyword, 10)
  ]);

  return {
    jobs: [...remotiveJobs, ...hnJobs],
    articles,
    timestamp: new Date().toISOString()
  };
}

Solving Browser Network Walls: Handling CORS in Job and News Aggregators

When you call public APIs directly from client-side JavaScript, you will occasionally encounter cross-origin resource sharing errors (such as Access-Control-Allow-Origin missing). While HackerNews, Remotive, and Dev.to provide open CORS headers, enterprise portals like Adzuna often block direct browser fetches to safeguard API keys from exposure in client network inspectors.

Never install unsafe browser extensions that bypass CORS restrictions locally. Disabling CORS in your personal browser creates a false sense of security while leaving your hosted application broken for recruiters. Instead, route protected calls through a lightweight serverless function (such as a Next.js API route or Express handler) that stores your credentials safely on the server side. For complete instructions and working proxy templates, read our guide on how to fix CORS errors when calling public APIs.

The Elder Brother Takeaway: Your Portfolio Is Your Proof of Competence

When you come from a non-traditional background or a college that does not attract campus placements, the job hunt feels like an uphill battle. Sending fifty resumes a day to generic corporate portals will drain your enthusiasm and leave you questioning your abilities.

Break the cycle. Stop playing the lottery with crowded job boards and start engineering your own solutions. When you build a live tool like DevPulse, you prove three things that every engineering manager cares about:

1. You know how to integrate real APIs: You handle network timeouts, parse inconsistent payloads, and manage asynchronous state without crashing.
2. You understand performance: You implemented in-memory TTL caching so your app respects rate limits and runs fast even on slow mobile connections.
3. You possess initiative: Instead of waiting for opportunities to fall into your lap, you built an engineering tool that solves a real problem for you and your fellow developers.

Open your editor, fetch remote job data from Remotive and HackerNews, and deploy your career aggregator to Vercel or Netlify. That single project will do more for your resume than twenty standard bootcamp exercises ever could.