Skip to main content
The official Python, Node.js, and .NET clients handle pagination, retries, and typed models. All three are at 4.0.0 and cover the same endpoints. Auto Apply has its own TypeScript client, and every endpoint also works without a client library.
4.0.0 is a breaking release: the EmploymentType, ExperienceLevel, and CompensationPeriod value sets changed, and the retired Auto Apply sub-client is gone. Pin an exact version (see Versioning) and read Upgrading to 4.0.0 before you upgrade from 3.x, or from 1.x on Node.

What the 4.0.0 clients do not cover

Send these over plain HTTPS:

Upgrading to 4.0.0

What the changes mean:
  • The index matches both employment-type spellings, so the new values change what goes over the wire, not what you get back.
  • freelance and intern exist in the data; the old enums could not express them.
  • The old Auto Apply sub-client’s create_profile / start_session / set_answers called routes that no longer exist, so nothing on it worked. The live contract is profileless and synchronous.

Python

Filters and options are keyword-only; the job ID, the company ID, and the string passed to geocode are positional. Date arguments take datetime objects, not strings.
JoboClient(api_key, *, base_url="https://connect.jobo.world", timeout=30.0, feed_timeout=120.0, httpx_client=None) takes timeouts in seconds. A passed httpx_client is used as is: the client ignores api_key, base_url, and timeout, so set the base URL and the X-Api-Key header on it yourself. For async code, AsyncJoboClient takes the same arguments and method names. Open it with async with, await its methods, and use async for on the iter_* methods:

Auto-pagination

The iter_* methods fetch pages and follow cursors for you.

Incremental sync

Pass updated_after to pick up changes after a backfill. Feed scans page by immutable creation time by default (stable_scan), so records can’t shift across page boundaries mid-read.

Errors

The client retries 429 and 503 up to 3 times. It honors Retry-After, otherwise backs off exponentially, and caps each wait at 30 seconds. Every other error response, 500 included, raises an exception derived from JoboError:
Every exception carries the problem code when the API supplies one, plus status_code, detail, api_version, and the raw response_body. JoboRateLimitError also carries retry_after. To retry a 500, catch JoboServerError and apply the retry strategy.

Node.js and TypeScript

The client has no runtime dependencies and uses the built-in fetch, so it needs Node 18+ and also runs in Bun and Deno. Use it server-side only: never ship your API key to a browser. Options are camelCase and accept a Date or an ISO 8601 string for dates; wire fields on response objects stay snake_case.
new JoboClient({ apiKey, baseUrl?, timeout?, feedTimeout?, fetch? }) takes timeouts in milliseconds (defaults 30000 and 120000). The iterators are async generators:
Retries and errors match the Python client: 429 and 503 are retried, and every other error response throws the JoboError subclass of the same name (JoboRateLimitError carries retryAfter). Error properties are camelCase: statusCode, responseBody, apiVersion.

.NET

The package targets net6.0 and net8.0, and JoboClient is IDisposable. JoboClientOptions also takes BaseUrl, Timeout (default 30 seconds), and FeedTimeout (default 120 seconds). To register a singleton with dependency injection, add using Jobo.Enterprise.Client.Extensions; and call services.AddJoboClient(o => o.ApiKey = ...). Feed enumeration returns IAsyncEnumerable<Job>:
If you pass your own HttpClient instead of JoboClientOptions, the client applies no settings to it. Set BaseAddress (https://connect.jobo.world), the X-Api-Key default header, and, if you use the feed endpoints, a Timeout of at least 120 seconds. Exceptions live in Jobo.Enterprise.Client.Exceptions and use the Exception suffix: JoboException, JoboRateLimitException (with RetryAfterSeconds), and so on. Each carries Code, StatusCode, Detail, ResponseBody, and ApiVersion.

Auto Apply (TypeScript)

@jobo-ai/autoapply covers the whole Auto Apply API, applications and mailboxes, and drives the synchronous application loop for you. It has no runtime dependencies and runs on Node 20+, Bun, Deno, and edge runtimes. Request and response properties are snake_case, as on the wire; option objects (idempotencyKey, waitSeconds, onStep) are camelCase. Auto Apply is coming soon. Build against the sandbox today with a sandbox key (jbe_test_…); live applications open once Jobo approves your business. createClient({ apiKey, baseUrl?, fetch?, maxRetries?, timeoutMs? }) returns { applications, mailboxes }. Version 2 targets API contract 2026-08-31. Its field types require only the stable base properties; options, constraints, format, sensitivity, and repeating-group metadata are optional, as they are on the wire.
run() creates the application, calls onStep for each step that needs answers (correction rounds included), reconnects after 202 responses, and resolves with the terminal application. Return { cancel: true } from onStep to cancel instead.
  • jobo.applications also exposes create, submitAnswers, get, cancel, and list. list auto-paginates with for await.
  • jobo.mailboxes covers mailboxes: create, get, list, delete, check, and retrieveVerification.
  • The required Idempotency-Key is sent for you. Pass a persisted idempotencyKey to recover a create across process restarts.
  • Validation failures throw JoboValidationError with per-field errors. Other API errors throw JoboAPIError, carrying the problem code and retryAfterSeconds.
  • Network errors, 429, 502, and 503 are retried (maxRetries, default 2), and create also retries 409 idempotency_key_in_flight.
See The application loop for the underlying contract.

Without a client library

Every endpoint is plain HTTPS with a single X-Api-Key header, so the curl examples in these docs translate to any language:
You then handle the error responses and the retry strategy yourself. See Versioning for the compatibility contract your client code can rely on.