WhatJobs Getting Started: API Access and First Request (2026)

Getting started overview

Integrating with WhatJobs generally involves a sequence of steps designed to enable programmatic access to job listing data. This guide outlines the process from initial account setup to making a successful API call. The core components of this integration are account creation, obtaining necessary API credentials, and then structuring an HTTP request that incorporates these credentials to interact with the WhatJobs platform.

The WhatJobs platform provides data for job search and posting functionalities, serving both job seekers and organizations looking to publish vacancies or source candidates. Typical use cases include populating custom job boards, integrating job search capabilities into existing applications, or automating the submission of job openings to the WhatJobs network. As with many API integrations, understanding the authentication mechanism and the expected request/response formats is key to a smooth implementation.

Before proceeding, ensure you have access to a development environment where you can execute HTTP requests, such as a command-line tool like curl, a programming language with HTTP client libraries (e.g., Python's requests, Node.js's axios), or an API client like Postman. Familiarity with JSON data format is also beneficial, as it is the standard for API responses.

Quick Reference Table

Create an account and get keys

The first step in integrating with WhatJobs is to establish an account on their platform. This account serves as your identity for accessing developer resources and managing your API credentials. Navigate to the official WhatJobs registration page and follow the prompts to create a new user profile. This typically involves providing an email address, setting a password, and agreeing to the terms of service.

Once your account is active, you will need to locate and generate your API key. API keys are unique identifiers that authenticate your application when it makes requests to the WhatJobs API. They ensure that your application is authorized to access the requested resources and help WhatJobs track API usage. The exact location for API key generation can vary, but it is commonly found within a 'Developer Settings', 'API Management', or 'My Account' section of your user dashboard after logging in.

When you generate your API key, it is crucial to handle it securely. Treat your API key like a password: do not embed it directly in client-side code, commit it to public version control systems, or share it unnecessarily. Best practices for API key security include using environment variables, a secrets management service, or server-side proxies to call the API. For initial testing, you might use it directly, but always transition to a more secure method for production deployments.

After generating the key, copy it immediately. Some platforms only display the full key once, and you may need to generate a new one if you lose it. Store it in a secure, accessible location for your development environment.

Your first request

With an account created and your API key secured, you can now construct and execute your first API request to WhatJobs. This initial request will typically be a simple query to verify your credentials and ensure connectivity to the API service. The WhatJobs API usually exposes endpoints for searching job listings.

API Endpoint and Parameters

While specific endpoints and required parameters can vary, a common pattern for job board APIs is a search endpoint that accepts parameters like keywords, location, and pagination. For demonstration, we will assume a generic job search endpoint and required an API key parameter.

• API Base URL: https://api.whatjobs.com/v1/ (This is an illustrative example; consult the official WhatJobs API documentation for the exact base URL and endpoints.)
• Endpoint for Job Search: /jobs/search (Illustrative)
• Authentication: API Key passed as a query parameter (e.g., ?api_key=YOUR_API_KEY) or as an Authorization header (e.g., Authorization: Bearer YOUR_API_KEY, though query parameters are often simpler for initial setup).
• Example Query Parameters: q=software+engineer (keywords), location=London, limit=10.

Example Request (using curl)

Replace YOUR_API_KEY with the actual key obtained from your WhatJobs dashboard.

curl -X GET \
  "https://api.whatjobs.com/v1/jobs/search?api_key=YOUR_API_KEY&q=software+developer&location=New+York&limit=5" \
  -H "Accept: application/json"

This curl command performs an HTTP GET request to the hypothetical WhatJobs job search endpoint. It includes your API key, searches for "software developer" jobs in "New York", and requests a limit of 5 results. The -H "Accept: application/json" header indicates that your client prefers to receive the response in JSON format.

Expected Response

A successful request will typically return a JSON object containing an array of job listings. Each job listing will include details such as the job title, company, location, description, and a link to the original posting. An example of a successful (truncated) JSON response might look like this:

{
  "status": "success",
  "total_results": 12345,
  "jobs": [
    {
      "id": "job123",
      "title": "Software Developer",
      "company": "Tech Solutions Inc.",
      "location": "New York, NY",
      "description": "Developing scalable applications...",
      "url": "https://www.whatjobs.com/job/software-developer-tech-solutions-inc"
    },
    // ... more job objects
  ]
}

If the request fails, the API will typically return an error response, also in JSON, indicating the problem (e.g., invalid API key, missing parameters). Error handling is an important part of API integration, and you should design your application to gracefully manage these responses.

Common next steps

After successfully making your first API call and retrieving job data, several common next steps can enhance your integration with WhatJobs:

1. Explore Additional Endpoints: Review the comprehensive WhatJobs API documentation (Illustrative link; replace with actual API docs) to discover other available endpoints. These might include functionalities for posting jobs, managing applications, or retrieving specific job details by ID. Understanding the full scope of the API will allow you to build more robust applications.
2. Implement Advanced Search and Filtering: Beyond basic keyword and location searches, explore parameters for filtering by salary range, job type (full-time, part-time), experience level, and publication date. This allows users to refine their job searches effectively.
3. Pagination and Rate Limiting: For applications that retrieve large datasets, implement pagination to fetch results in manageable chunks. Also, be aware of WhatJobs's API rate limits to prevent your application from being temporarily blocked. Implement retry logic with exponential backoff for rate-limited responses, as recommended by Google's API client library guide.
4. Error Handling and Logging: Develop comprehensive error handling mechanisms to gracefully manage API errors, such as invalid parameters, authentication failures, or server-side issues. Implement logging to monitor API calls and identify potential problems during development and production.
5. Webhooks for Real-Time Updates: Investigate whether WhatJobs offers webhooks. Webhooks can provide real-time notifications for events like new job postings or updates to existing ones, reducing the need for constant polling and ensuring your data remains fresh. For an example of how webhooks operate, consider Twilio's webhook documentation.
6. Secure API Key Management: Move beyond hardcoding your API key. Implement secure methods for storing and accessing credentials, such as environment variables, a dedicated secrets management service, or a server-side proxy.
7. UI/UX Integration: Design and implement the user interface elements that will display the job data retrieved from WhatJobs. Consider aspects like search forms, job listing cards, detailed job pages, and application workflows.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps and common problems to address:

• Invalid API Key:
  • Symptom: An error response indicating "Unauthorized," "Invalid API Key," or similar.
  • Solution: Double-check that you have copied your API key correctly from your WhatJobs dashboard. Ensure there are no leading or trailing spaces. Verify that the key is being passed in the correct parameter name (e.g., api_key) and in the expected location (query parameter or header).
• Incorrect Endpoint URL:
  • Symptom: "404 Not Found" or "Cannot connect to host."
  • Solution: Confirm the base URL and the specific endpoint path are exactly as specified in the WhatJobs API documentation (Illustrative link; replace with actual API docs). Check for typos in the hostname or path segments.
• Missing or Incorrect Parameters:
  • Symptom: "400 Bad Request" with a message about missing or invalid parameters.
  • Solution: Review the required parameters for the endpoint you are calling. Ensure all mandatory parameters are present and that their values are in the correct format (e.g., strings, numbers, booleans). Check for proper URL encoding of special characters in query parameters (e.g., spaces converted to %20 or +).
• Network Connectivity Issues:
  • Symptom: "Connection Refused," "Timeout," or no response.
  • Solution: Verify your internet connection. Check if any firewalls or network proxies are blocking outbound connections from your development environment to the WhatJobs API servers. Try accessing other public websites to confirm general connectivity.
• JSON Parsing Errors:
  • Symptom: Your application fails when trying to parse the API response.
  • Solution: Ensure the Accept: application/json header is sent so the API provides a JSON response. Use a tool like jq (for command line) or an online JSON formatter to inspect the raw API response and confirm it is valid JSON. This often points to an issue with your JSON parsing logic.
• Rate Limiting:
  • Symptom: "429 Too Many Requests" error.
  • Solution: If you are making many requests in a short period, you might hit a rate limit. Wait for a few minutes and try again. For continuous integration, implement a delay between requests or use an exponential backoff strategy if the API documentation recommends it.