> ## Documentation Index
> Fetch the complete documentation index at: https://jobo.world/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Start

> Get your first API response in under 5 minutes — from zero to live job data.

## Prerequisites

Before you begin, make sure you have:

<CardGroup cols={2}>
  <Card title="Jobo Enterprise Account" icon="user-plus">
    [Sign up for free](https://enterprise.jobo.world/register) if you don't have one yet.
  </Card>

  <Card title="API Key" icon="key">
    Navigate to **Settings → API Keys** in the
    [dashboard](https://enterprise.jobo.world/api-keys) to generate your
    key.
  </Card>
</CardGroup>

<Tip>
  Store your API key in an environment variable for easy use: `bash export
      JOBO_API_KEY="your_api_key_here" # macOS/Linux set
      JOBO_API_KEY=your_api_key_here # Windows CMD
      $env:JOBO_API_KEY="your_api_key_here" # PowerShell `
</Tip>

***

## Get Started in 3 Steps

<Steps>
  <Step title="Install an SDK (optional)">
    Pick your language — or skip this step and use raw HTTP with cURL.

    <CodeGroup>
      ```bash Python theme={null}
      pip install jobo-enterprise
      ```

      ```bash Node.js theme={null}
      npm install jobo-enterprise
      ```

      ```bash .NET theme={null}
      dotnet add package Jobo.Enterprise.Client
      ```
    </CodeGroup>

    <Info>
      SDKs handle authentication, pagination, retries, and type safety for you.
      See the [Client Libraries](/sdks) page for full details.
    </Info>
  </Step>

  <Step title="Make Your First Request">
    Search for **software engineer** jobs and retrieve five results:

    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://connect.jobo.world/api/jobs?q=software+engineer&page_size=5" \
        -H "X-Api-Key: $JOBO_API_KEY"
      ```

      ```python Python theme={null}
      from jobo_enterprise import JoboClient

      client = JoboClient(api_key="YOUR_API_KEY")

      results = client.jobs.search(
          q="software engineer",
          page_size=5
      )

      for job in results.jobs:
          print(f"{job.title} at {job.company.name}")
      ```

      ```javascript Node.js theme={null}
      import { JoboClient } from 'jobo-enterprise';

      const client = new JoboClient({ apiKey: 'YOUR_API_KEY' });

      const results = await client.jobs.search({
        q: 'software engineer',
        pageSize: 5,
      });

      results.jobs.forEach(job => {
        console.log(`${job.title} at ${job.company.name}`);
      });
      ```

      ```csharp .NET theme={null}
      using Jobo.Enterprise.Client;

      var client = new JoboClient("YOUR_API_KEY");

      var results = await client.Jobs.SearchAsync(new SearchRequest
      {
          Q = "software engineer",
          PageSize = 5
      });

      foreach (var job in results.Jobs)
      {
          Console.WriteLine($"{job.Title} at {job.Company.Name}");
      }
      ```
    </CodeGroup>
  </Step>

  <Step title="Parse the Response">
    The API returns a JSON object with a `jobs` array and pagination metadata:

    ```json theme={null}
    {
      "jobs": [
        {
          "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
          "title": "Senior Software Engineer",
          "company": {
            "name": "Acme Corp",
            "website": "https://acme.com",
            "logo_url": "https://logo.clearbit.com/acme.com"
          },
          "locations": [
            {
              "city": "San Francisco",
              "region": "California",
              "country": "United States"
            }
          ],
          "compensation": {
            "min": 150000,
            "max": 200000,
            "currency": "USD",
            "period": "year"
          },
          "is_remote": true,
          "source": "greenhouse",
          "date_posted": "2026-02-28T00:00:00Z",
          "apply_url": "https://boards.greenhouse.io/acme/jobs/123456"
        }
      ],
      "total": 12847,
      "page": 1,
      "page_size": 5,
      "total_pages": 2570
    }
    ```
  </Step>
</Steps>

***

## Response Breakdown

Understanding the key fields in the response:

| Field                 | Type              | Description                                                                     |
| --------------------- | ----------------- | ------------------------------------------------------------------------------- |
| `jobs`                | array             | List of job objects matching your query                                         |
| `jobs[].id`           | string (UUID)     | Unique identifier for the job listing                                           |
| `jobs[].title`        | string            | Job title as posted by the employer                                             |
| `jobs[].company`      | object            | Company info including `name`, `website`, and `logo_url`                        |
| `jobs[].locations`    | array             | Structured locations with `city`, `region`, `country`, and optional `lat`/`lng` |
| `jobs[].compensation` | object            | Salary data with `min`, `max`, `currency`, and `period` (year/hour/month)       |
| `jobs[].is_remote`    | boolean           | Whether the position allows remote work                                         |
| `jobs[].source`       | string            | ATS platform the job was scraped from (e.g. `greenhouse`, `lever`, `workday`)   |
| `jobs[].date_posted`  | string (ISO 8601) | When the job was first published                                                |
| `jobs[].apply_url`    | string            | Direct link to the original application page                                    |
| `total`               | integer           | Total number of jobs matching your query                                        |
| `page`                | integer           | Current page number (1-indexed)                                                 |
| `page_size`           | integer           | Number of results per page (max 100)                                            |
| `total_pages`         | integer           | Total pages available                                                           |

<Info>
  For the complete job schema including all available fields, see the [Job
  Schema](/resources/job-schema) reference.
</Info>

***

## Common First Steps

Once your first request is working, try these common patterns:

<AccordionGroup>
  <Accordion title="Search by Keyword">
    Use the `q` parameter to do full-text search across job titles, company names, skills, and summaries. Wrap the value in double quotes (`q="data scientist"`) for an exact, title-only phrase match.

    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://connect.jobo.world/api/jobs?q=data+scientist&page_size=10" \
        -H "X-Api-Key: $JOBO_API_KEY"
      ```

      ```python Python theme={null}
      results = client.jobs.search(q="data scientist", page_size=10)
      ```

      ```javascript Node.js theme={null}
      const results = await client.jobs.search({ q: 'data scientist', pageSize: 10 });
      ```

      ```csharp .NET theme={null}
      var results = await client.Jobs.SearchAsync(new SearchRequest
      {
          Q = "data scientist",
          PageSize = 10
      });
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Filter by Location">
    Pass a `location` parameter to narrow results to a specific city, state, or country.

    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://connect.jobo.world/api/jobs?q=product+manager&location=New+York" \
        -H "X-Api-Key: $JOBO_API_KEY"
      ```

      ```python Python theme={null}
      results = client.jobs.search(q="product manager", location="New York")
      ```

      ```javascript Node.js theme={null}
      const results = await client.jobs.search({ q: 'product manager', location: 'New York' });
      ```

      ```csharp .NET theme={null}
      var results = await client.Jobs.SearchAsync(new SearchRequest
      {
          Q = "product manager",
          Location = "New York"
      });
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Filter by Remote">
    Set `is_remote=true` to return only remote-friendly positions.

    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://connect.jobo.world/api/jobs?q=frontend+engineer&is_remote=true" \
        -H "X-Api-Key: $JOBO_API_KEY"
      ```

      ```python Python theme={null}
      results = client.jobs.search(q="frontend engineer", is_remote=True)
      ```

      ```javascript Node.js theme={null}
      const results = await client.jobs.search({ q: 'frontend engineer', isRemote: true });
      ```

      ```csharp .NET theme={null}
      var results = await client.Jobs.SearchAsync(new SearchRequest
      {
          Q = "frontend engineer",
          IsRemote = true
      });
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Paginate Through Results">
    Use `page` and `page_size` to iterate through large result sets. SDKs handle this automatically.

    <CodeGroup>
      ```bash cURL theme={null}
      # Page 1
      curl "https://connect.jobo.world/api/jobs?q=engineer&page=1&page_size=50" \
        -H "X-Api-Key: $JOBO_API_KEY"

      # Page 2
      curl "https://connect.jobo.world/api/jobs?q=engineer&page=2&page_size=50" \
        -H "X-Api-Key: $JOBO_API_KEY"
      ```

      ```python Python theme={null}
      # Manual pagination
      page = 1
      while True:
          results = client.jobs.search(q="engineer", page=page, page_size=50)
          for job in results.jobs:
              print(job.title)
          if page >= results.total_pages:
              break
          page += 1

      # Or use auto-pagination (recommended)
      for job in client.jobs.search_iter(q="engineer"):
          print(job.title)
      ```

      ```javascript Node.js theme={null}
      // Manual pagination
      let page = 1;
      let totalPages = 1;
      do {
        const results = await client.jobs.search({ q: 'engineer', page, pageSize: 50 });
        results.jobs.forEach(job => console.log(job.title));
        totalPages = results.totalPages;
        page++;
      } while (page <= totalPages);

      // Or use auto-pagination (recommended)
      for await (const job of client.jobs.searchIter({ q: 'engineer' })) {
        console.log(job.title);
      }
      ```

      ```csharp .NET theme={null}
      // Auto-pagination with IAsyncEnumerable
      await foreach (var job in client.Jobs.SearchEnumerableAsync(new SearchRequest
      {
          Q = "engineer"
      }))
      {
          Console.WriteLine(job.Title);
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Search API" icon="magnifying-glass" href="/api-reference/jobs/search">
    Explore all search parameters — keyword, location, date range, ATS source,
    and more
  </Card>

  <Card title="Advanced Query" icon="filter" href="/api-reference/jobs/search#advanced-search">
    Build composable filters with AND/OR logic for complex searches
  </Card>

  <Card title="Jobs Feed" icon="rss" href="/api-reference/feed/jobs-feed">
    Stream high-volume job data in incremental batches via cursor-based
    pagination
  </Card>

  <Card title="Auto Apply" icon="bolt" href="/api-reference/auto-apply/auto-apply">
    Automate job applications with browser-driven form filling
  </Card>

  <Card title="Data Platform" icon="database" href="/data-platform/overview">
    Export to CSV, JSON, or Parquet — or sync directly to your database
  </Card>

  <Card title="Client Libraries" icon="puzzle-piece" href="/sdks">
    Official SDKs with auto-pagination, retries, and full type safety
  </Card>
</CardGroup>