Findwork Getting Started Guide: API Keys & First Request (2026)

Getting started overview

Integrating with the Findwork API involves a few key steps: account creation, API key generation, and making your first authenticated request. This guide provides a structured approach to quickly set up your development environment and retrieve job data. Findwork offers a free tier that includes 500 API calls per month, allowing developers to test and build applications without an initial financial commitment.

The Findwork API is a RESTful API, which means it uses standard HTTP methods (like GET) to access and manipulate resources. Data is typically returned in JSON format, a lightweight data-interchange format designed for human readability and machine parsing. Understanding these foundational concepts will help you effectively utilize the API.

This guide will walk you through:

• Creating a Findwork developer account.
• Obtaining your unique API key.
• Constructing and executing a basic API request to fetch job listings.
• Common issues and solutions for initial setup.

By the end of this guide, you will have successfully made a call to the Findwork API and received a response, laying the groundwork for more complex integrations.

Create an account and get keys

Accessing the Findwork API requires a developer account and an associated API key for authentication. The API key serves as a unique identifier and security credential for your application, allowing Findwork to verify your identity and authorize your requests.

Step-by-step account creation

1. Visit the Findwork Homepage: Navigate to the official Findwork website.
2. Sign Up: Look for a "Sign Up" or "Get Started" button, typically located in the header or a prominent section of the homepage. Click it to initiate the registration process.
3. Provide Details: You will likely be prompted to enter an email address and create a password. Follow any on-screen instructions to complete the registration. This may include verifying your email address through a link sent to your inbox.
4. Access Developer Dashboard: Once registered and logged in, you will be directed to your developer dashboard. This is your central hub for managing API keys, monitoring usage, and accessing documentation.

Generating your API key

Within the developer dashboard, you will find a section dedicated to API keys. If a key is not automatically generated upon account creation, you will need to create one manually:

1. Locate API Key Section: On your dashboard, find a tab or section labeled "API Keys," "Credentials," or similar.
2. Generate New Key: Click the "Generate New Key" or "Create Key" button. You may be asked to provide a name or description for your key, which can help you identify its purpose later if you manage multiple applications.
3. Secure Your Key: Your API key will be displayed. This key is sensitive and should be treated like a password. Do not hardcode it directly into client-side code, commit it to public version control systems, or share it unnecessarily. Store it securely, for example, using environment variables or a secret management service. Findwork's API documentation emphasizes the importance of secure key management.

Your first request

With your account set up and API key obtained, you can now make your first authenticated request to the Findwork API. We will use the Job Search API endpoint to retrieve a list of job postings.

API Endpoint

The primary endpoint for searching jobs is https://findwork.dev/api/jobs/.

Authentication

Findwork API uses API key authentication. Your API key should be included in the Authorization header of your HTTP request, prefixed with Token. For example: Authorization: Token YOUR_API_KEY.

Example Request (cURL)

cURL is a command-line tool and library for transferring data with URLs. It's a common way to test REST APIs without writing dedicated code. Replace YOUR_API_KEY with your actual API key.

curl -X GET \
  'https://findwork.dev/api/jobs/?search=developer&location=remote' \
  -H 'Authorization: Token YOUR_API_KEY'

This request searches for "developer" jobs in "remote" locations. The response will be a JSON object containing a list of job postings matching your criteria.

Example Request (Python)

Python's requests library simplifies making HTTP requests. Ensure you have it installed (pip install requests).

import requests
import os

api_key = os.environ.get("FINDWORK_API_KEY")
if not api_key:
    print("Error: FINDWORK_API_KEY environment variable not set.")
    exit()

headers = {
    'Authorization': f'Token {api_key}'
}

params = {
    'search': 'software engineer',
    'location': 'New York'
}

response = requests.get('https://findwork.dev/api/jobs/', headers=headers, params=params)

if response.status_code == 200:
    data = response.json()
    print("Successfully retrieved job listings:")
    for job in data.get('results', [])[:3]: # Print first 3 job titles
        print(f"- {job.get('title')}")
else:
    print(f"Error: {response.status_code} - {response.text}")

Remember to set your FINDWORK_API_KEY as an environment variable before running this Python script: export FINDWORK_API_KEY='YOUR_API_KEY' (Linux/macOS) or $env:FINDWORK_API_KEY='YOUR_API_KEY' (PowerShell).

Expected Response Structure

A successful response (HTTP status 200 OK) will contain a JSON object with a structure similar to this:

{
  "count": 1234,
  "next": "https://findwork.dev/api/jobs/?page=2&search=developer&location=remote",
  "previous": null,
  "results": [
    {
      "id": "...",
      "title": "Software Developer",
      "company_name": "Example Corp",
      "location": "Remote",
      "pub_date": "2026-05-29T10:00:00Z",
      "url": "https://example.com/job/123",
      "description": "..."
    },
    // More job objects
  ]
}

Common next steps

After successfully making your first request, you can expand your integration with Findwork by exploring additional features and optimizing your application:

• Explore Query Parameters: The Findwork API reference details numerous query parameters to refine your job searches, such as search, location, min_salary, max_salary, company, and tags. Experiment with these to filter results precisely. For example, you can filter jobs by specific skills or job types.
• Pagination: For queries that return a large number of results, Findwork employs pagination. Use the next and previous URLs provided in the response to navigate through pages of results efficiently. Understanding how to handle pagination in REST APIs is crucial for retrieving comprehensive datasets.
• Error Handling: Implement robust error handling in your application. Check the HTTP status codes returned by the API (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found, 429 Too Many Requests) and parse the error messages in the JSON response to provide meaningful feedback to users or for debugging.
• Rate Limiting: Be aware of Findwork's rate limits to avoid being temporarily blocked. Plan your API calls to stay within the allowed request frequency, especially when processing large volumes of data. Consider implementing exponential backoff for retries.
• Webhooks (If Available): If Findwork offers webhook functionality (check their documentation), consider using them to receive real-time notifications about new job postings or updates, rather than continuously polling the API. This can reduce API call volume and improve data freshness.
• Integrate into Application: Begin integrating the retrieved job data into your application's user interface or backend logic. This could involve displaying job listings, building a custom job board, or feeding data into a talent acquisition system.

Troubleshooting the first call

Encountering issues during your first API call is common. Here's a table of typical problems and their solutions:

import os
api_key = os.environ.get("FINDWORK_API_KEY")
if not api_key:
    print("Environment variable FINDWORK_API_KEY not set.")
    # Optionally, handle by loading from a config file or prompting
    exit(1)

Quick Reference: Findwork Getting Started Steps