{"id":51867278,"url":"https://github.com/apify/apify-client-java","last_synced_at":"2026-07-24T18:00:57.282Z","repository":{"id":370692425,"uuid":"1287957391","full_name":"apify/apify-client-java","owner":"apify","description":"Apify API client for Java—Programmatically run Actors, manage and stream data from storages (datasets, key-value stores, request queues), schedule and monitor runs, and access the full Apify platform API. Sync and async interfaces with automatic retries and pagination. ","archived":false,"fork":false,"pushed_at":"2026-07-20T16:19:14.000Z","size":337,"stargazers_count":1,"open_issues_count":2,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2026-07-20T17:14:17.609Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"https://central.sonatype.com/artifact/com.apify/apify-client","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/apify.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-07-03T06:35:53.000Z","updated_at":"2026-07-15T12:44:45.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/apify/apify-client-java","commit_stats":null,"previous_names":["apify/apify-client-java"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/apify/apify-client-java","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/apify%2Fapify-client-java","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/apify%2Fapify-client-java/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/apify%2Fapify-client-java/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/apify%2Fapify-client-java/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/apify","download_url":"https://codeload.github.com/apify/apify-client-java/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/apify%2Fapify-client-java/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35850518,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-07-20T02:08:10.276Z","status":"online","status_checked_at":"2026-07-24T02:00:07.870Z","response_time":62,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-07-24T18:00:56.266Z","updated_at":"2026-07-24T18:00:57.270Z","avatar_url":"https://github.com/apify.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Apify API client for Java\n\n\u003e **Official, but experimental — AI-generated and AI-maintained.** This is an official Apify client,\n\u003e but it is experimental: it is generated and maintained by AI. Review the code before relying on it\n\u003e in production and report issues on the repository.\n\nA resource-oriented Java client for the [Apify API](https://docs.apify.com/api/v2), mirroring the\nofficial [JavaScript](https://github.com/apify/apify-client-js) reference client: start from an\n`ApifyClient`, then drill down into resources (Actors, runs, datasets, key-value stores, request\nqueues, tasks, schedules, webhooks, the store, users and logs).\n\n## Requirements\n\n- Java 17 or newer.\n\n## Installation\n\nThe client is published to [Maven Central](https://central.sonatype.com/artifact/com.apify/apify-client).\n\nMaven (Maven Central is a default repository, so no extra configuration is needed):\n\n```xml\n\u003cdependency\u003e\n  \u003cgroupId\u003ecom.apify\u003c/groupId\u003e\n  \u003cartifactId\u003eapify-client\u003c/artifactId\u003e\n  \u003cversion\u003e0.5.0\u003c/version\u003e\n\u003c/dependency\u003e\n```\n\nGradle — ensure `mavenCentral()` is in your `repositories`, then add the dependency:\n\n```groovy\nrepositories {\n  mavenCentral()\n}\n\ndependencies {\n  implementation 'com.apify:apify-client:0.5.0'\n}\n```\n\n## Quick start\n\nAfter adding the dependency (above), create an `ApifyClient`, then drill down into a resource:\n\n```java\nimport com.apify.client.ApifyClient;\nimport com.apify.client.run.ActorRun;\nimport com.apify.client.actor.ActorStartOptions;\n\nclass HelloApify {\n  public static void main(String[] args) {\n    // Your API token from https://console.apify.com/settings/integrations\n    ApifyClient client = ApifyClient.create(System.getenv(\"APIFY_TOKEN\"));\n    ActorRun run = client.actor(\"apify/hello-world\").call(null, new ActorStartOptions(), 120L).join();\n    System.out.println(\"Run \" + run.getId() + \" finished with status \" + run.getStatus());\n  }\n}\n```\n\n`ApifyClient.create` takes the token as an explicit argument — it does **not** read `APIFY_TOKEN` (or\nany other environment variable) automatically. Read it yourself if you want that, e.g.\n`ApifyClient.create(System.getenv(\"APIFY_TOKEN\"))`.\n\nAll public client types live under `com.apify.client`, split by resource into sub-packages (e.g.\n`com.apify.client.run.ActorRun`, `com.apify.client.dataset.DatasetListItemsOptions`) — see\n[Resources](#resources) below for the full list; [`docs/README.md`](docs/README.md#imports-and-dependencies)\nenumerates the model/option-type packages. The Quick start example above is a complete, runnable\nprogram (imports, class, `main`); every other snippet in this file, from here on, is a fragment\nthat assumes a configured `client` and the correct imports for the types it uses — not, by itself,\na complete program — the [resource pages](docs/README.md) show the same kind of fragment per\nmethod. Reading items from a run's default dataset, chaining the two asynchronous calls:\n\n```java\nclient.actor(\"apify/hello-world\").call(null, new ActorStartOptions(), 120L)\n    .thenCompose(run -\u003e client.dataset(run.getDefaultDatasetId())\n        .listItems(new DatasetListItemsOptions()))\n    .thenAccept(items -\u003e System.out.println(\"Items in this page: \" + items.getCount()))\n    .join();\n```\n\nThe types used above — `PaginationList\u003cT\u003e` (root package), `DatasetListItemsOptions`\n(`com.apify.client.dataset`), and the per-resource clients — are documented on the\n[resource pages](docs/README.md); `ApifyApiException` (`com.apify.client.http`) is covered under\n[Error handling](#error-handling) below. [`docs/examples.md`](docs/examples.md) has more fragments\nin the same style (build-and-run, storages, log redirection, and more); the complete, runnable\nprograms live under\n[`src/test/java/com/apify/client/examples/`](https://github.com/apify/apify-client-java/tree/master/src/test/java/com/apify/client/examples).\n\n## Asynchronous API\n\nEvery network-calling method returns a\n[`CompletableFuture`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html)\n(`java.util.concurrent.CompletableFuture`) instead of blocking the calling thread on the HTTP\nexchange, and every paginated collection's `iterate(...)` returns a\n[`Flow.Publisher`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/Flow.Publisher.html)\n(`java.util.concurrent.Flow.Publisher`) — the JDK's built-in Reactive Streams type — instead of a\nblocking `Iterator`, so following a large collection never blocks a thread waiting on the next\npage's network round-trip.\n\n- **Chain calls** with `thenApply`/`thenCompose`/`thenAccept` (see the dataset example above) to\n  keep a pipeline fully asynchronous end to end.\n- **Block for a result** with `future.join()` (unchecked) or `future.get()` (checked,\n  `InterruptedException`/`ExecutionException`) when you just want a synchronous-looking call site\n  (e.g. a `main` method, a test, or a simple script) — every snippet in this documentation that\n  needs a value calls `.join()` for exactly that reason.\n- **Consume an `iterate(...)` publisher** either by implementing `Flow.Subscriber\u003cT\u003e` yourself\n  (`onSubscribe` → `request(n)` to pull `n` items, `onNext` per item, `onComplete`/`onError` to\n  finish) for real backpressure, or with the small convenience bridge\n  `com.apify.client.Publishers.collect(publisher)`, which subscribes with unbounded demand and\n  returns a `CompletableFuture\u003cList\u003cT\u003e\u003e` — useful when you just want \"give me everything\" and don't\n  need backpressure:\n\n  ```java\n  List\u003cActor\u003e actors = Publishers.collect(client.actors().iterate(new ActorListOptions())).join();\n  ```\n\nA future/publisher's failure mode is unchanged from before: any `ApifyApiException`/\n`ApifyTransportException` this client throws now arrives as the future's exceptional completion\n(surfaced by `.join()`/`.get()` as a `CompletionException`/`ExecutionException` wrapping the\noriginal, still-unchecked exception) instead of a direct `throw` — see\n[Error handling](#error-handling) below for the full exception hierarchy, which is otherwise\nunchanged.\n\n## Configuration\n\nUse `ApifyClient.builder()` for non-default settings:\n\n```java\nApifyClient configured =\n    ApifyClient.builder()\n        .token(\"my-api-token\")\n        .baseUrl(\"https://api.apify.com\") // /v2 is appended automatically\n        .maxRetries(8)\n        .minDelayBetweenRetries(Duration.ofMillis(500))\n        .timeout(Duration.ofSeconds(360))\n        .userAgentSuffix(\"MyTool/1.0\")\n        .build();\n```\n\n`Duration` above is `java.time.Duration`.\n\n### `ApifyClientBuilder` reference\n\nEvery setter is optional; leaving one uncalled keeps its default. `int`/`Duration` arguments are\nvalidated at call time (see below), not deferred to `build()`.\n\n| Setter | Type | Default | Valid range |\n|---|---|---|---|\n| `token(String)` | `String` | none (unauthenticated) | any non-null string |\n| `baseUrl(String)` | `String` | `https://api.apify.com` (`/v2` appended automatically) | non-null, non-blank |\n| `publicBaseUrl(String)` | `String` | same as `baseUrl` | non-null, non-blank |\n| `maxRetries(int)` | `int` | `8` | `\u003e= 0` |\n| `minDelayBetweenRetries(Duration)` | `Duration` | `500ms` | non-null, `\u003e= 0` |\n| `maxDelayBetweenRetries(Duration)` | `Duration` | same as `timeout` (`360s`) | non-null, `\u003e= 0` |\n| `timeout(Duration)` | `Duration` | `360s` | non-null, strictly `\u003e 0` |\n| `userAgentSuffix(String)` | `String` | none (no suffix appended) | any string |\n| `httpTransport(HttpTransport)` | `HttpTransport` | `new DefaultHttpTransport()` | non-null |\n\nA violated range throws `IllegalArgumentException` from the setter itself. `timeout` is the ceiling\neach retry attempt's per-request (socket) timeout grows toward — not a wall-clock bound on the\ncumulative time across all retries; the connection-establishment timeout is a separate,\ntransport-level setting (see `DefaultHttpTransport`'s constructors below).\n\n`publicBaseUrl` does not affect ordinary API requests (those always use `baseUrl`); it only changes\nthe origin embedded in the handful of public, directly-fetchable URLs the client builds without a\nrequest — `DatasetClient.createItemsPublicUrl(...)` and `KeyValueStoreClient.getRecordPublicUrl(...)`/\n`createKeysPublicUrl(...)` (see [Storages](docs/storages.md)). Set it when the API is reached\nthrough one origin (e.g. an internal proxy) but those public URLs must point at a different,\nexternally-reachable one.\n\n### Replaceable HTTP transport\n\nThe transport is a replaceable component. The default is `DefaultHttpTransport` (backed by the JDK's\n`java.net.http.HttpClient`); provide your own `HttpTransport` to share a connection pool or customize\nproxy/TLS:\n\n```java\nHttpTransport transport = new DefaultHttpTransport(java.net.http.HttpClient.newHttpClient());\nApifyClient withTransport = ApifyClient.builder().token(\"t\").httpTransport(transport).build();\n```\n\n`DefaultHttpTransport` also has a `DefaultHttpTransport(Duration connectTimeout)` constructor that\nbuilds its own JDK `HttpClient` with a custom connection-establishment timeout (default 10s,\n`DefaultHttpTransport.DEFAULT_CONNECT_TIMEOUT`) without requiring you to construct the `HttpClient`\nyourself — use it when you only want to change the connect timeout and don't otherwise need to\ncustomize the JDK client:\n\n```java\nHttpTransport transport = new DefaultHttpTransport(Duration.ofSeconds(5));\n```\n\nCross-cutting behaviour applied to every request lives in the client, not the transport\nimplementation: bearer-token authentication, the mandated `User-Agent` header, and retries with\nexponential backoff and jitter on `429`, `5xx` and network errors.\n\n#### `HttpTransport` contract\n\nA custom implementation (`com.apify.client.http.HttpTransport`) must provide both methods, both\nnon-blocking. `HttpRequest` and `HttpResponse\u003cT\u003e` below are the JDK's `java.net.http.HttpRequest`/\n`java.net.http.HttpResponse\u003cT\u003e` (not custom client types) — same as `Duration` above:\n\n| Method | Signature | Contract |\n|---|---|---|\n| `sendAsync` | `CompletableFuture\u003cHttpResponse\u003cbyte[]\u003e\u003e sendAsync(HttpRequest request)` | Sends the single, fully-prepared request (auth, `User-Agent` and any other headers are already set by the client) and completes the future with the response with its body fully buffered as `byte[]`. Used for every non-streaming call. |\n| `sendStreamingAsync` | `CompletableFuture\u003cHttpResponse\u003cInputStream\u003e\u003e sendStreamingAsync(HttpRequest request)` | Sends the request and completes the future with the response body as a live `InputStream` for incremental consumption, used by log streaming (`LogClient.stream(...)`). The *caller* (the client) is responsible for closing the returned stream; an implementation must not close it itself before completing the future. |\n\nBoth methods perform exactly one network round-trip each — no retrying, no request mutation\n(retries, auth, and the `User-Agent` header are handled one layer up, by the client itself), and\nneither may block the calling thread waiting on the network. A non-2xx HTTP status is **not** a\ntransport-level error: complete the future normally with it, as a normal `HttpResponse` carrying its\nactual status code. Only fail the future for a genuine transport failure — connection refused, DNS\nresolution failure, or a timeout. Any exception the future is completed exceptionally with is\ntranslated by the client into an `ApifyTransportException`; complete exceptionally with\n`com.apify.client.http.HttpTimeoutException` specifically for a timeout so\n`ApifyTransportException.isTimeout()` reports it correctly. `DefaultHttpTransport` implements both\nmethods directly on top of the JDK `HttpClient`'s own `sendAsync`.\n\n## Fetching single resources\n\nMethods that fetch a single resource complete with an `Optional\u003cT\u003e`: a missing resource is reported\nby an empty `Optional` rather than an exception.\n\n```java\nclient.actor(\"apify/hello-world\").get()\n    .thenAccept(actor -\u003e actor.ifPresent(a -\u003e System.out.println(a.getTitle())))\n    .join();\n```\n\n## Error handling\n\nEvery exception this client throws for a request/transport failure is an unchecked\n`com.apify.client.http.ApifyClientException`. It has two concrete subtypes, both also in\n`com.apify.client.http`. Since every network-calling method is asynchronous (see\n[Asynchronous API](#asynchronous-api) above), these exceptions arrive as the returned\n`CompletableFuture`'s exceptional completion rather than a direct `throw`; `.join()` re-throws the\noriginal exception wrapped in an unchecked `CompletionException` (`.get()` wraps it in a checked\n`ExecutionException` instead) — unwrap `getCause()` to recover the original\n`ApifyApiException`/`ApifyTransportException`, or use `.handle(...)`/`.exceptionally(...)` to react\nto it without unwrapping at all:\n\n- `ApifyApiException` — the request reached the API, which answered with a non-success status.\n- `ApifyTransportException` — the request never produced an API response at all (connection\n  failure, DNS, timeout, or a local failure preparing the request/response, e.g. compression).\n  `isTimeout()` reports whether the underlying cause was specifically a timeout (backed by\n  `com.apify.client.http.HttpTimeoutException`, part of the `HttpTransport` contract, not any\n  specific transport implementation's own exception type). Note the name collision: this is a\n  distinct type from the JDK's own `java.net.http.HttpTimeoutException` (which\n  `DefaultHttpTransport` catches internally and translates into this one) — use an explicit,\n  fully-qualified import or a clear alias if a file needs both.\n\nCatch `ApifyClientException` to handle both failure modes uniformly, or catch a specific subtype to\nhandle one of them differently. `ApifyApiException` is imported from `com.apify.client.http`:\n\nA few methods validate their own preconditions synchronously, before ever building a request or\nfuture, and throw a plain JDK exception directly from the call site instead, not an\n`ApifyClientException` subtype (so no `.join()`/`.get()` unwrapping is involved for these):\n`ApifyClient.setStatusMessage(message, options)` throws `IllegalStateException` if the\n`ACTOR_RUN_ID` environment variable is not set, `ApifyClient.me()`'s limits methods (`limits()`,\n`updateLimits(...)`, `monthlyUsage(...)`) throw the same `IllegalStateException` if called on a\n`UserClient` that is not `me()`, and `ApifyClientBuilder`'s setters throw `IllegalArgumentException`\non an invalid configuration value (e.g. a negative retry count). These are local, no-request-sent\nfailures, not something the API responded with or the transport failed to deliver, which is why\nthey stay outside the request/transport exception hierarchy above — catch\n`IllegalStateException`/`IllegalArgumentException` separately if you call any of them.\n\n```java\ntry {\n  client.actor(\"does/not-exist\").update(Map.of(\"title\", \"x\")).join();\n} catch (CompletionException e) {\n  if (e.getCause() instanceof ApifyApiException apiError) {\n    System.out.println(\"status=\" + apiError.getStatusCode() + \" type=\" + apiError.getType());\n  } else {\n    throw e;\n  }\n}\n```\n\n`ApifyApiException` exposes the parsed error details:\n\n| Accessor | Type | Meaning |\n|---|---|---|\n| `getStatusCode()` | `int` | HTTP status code of the error response. |\n| `getType()` | `String` (nullable) | Machine-readable error type (e.g. `record-not-found`). |\n| `getMessage()` | `String` | Human-readable description (also `Throwable.getMessage()`). |\n| `getAttempt()` | `int` | The (1-based) attempt number that produced the error. |\n| `getHttpMethod()` | `String` | The request's HTTP method. |\n| `getPath()` | `String` | The request's URL path. |\n| `getData()` | `Map\u003cString, Object\u003e` (nullable, unmodifiable) | Additional structured error data, if any. |\n\n## Versioning\n\nThe public `com.apify.client.Version` class (`import com.apify.client.Version;`) exposes two\nconstants:\n\n- `Version.CLIENT_VERSION` — the semantic version of this client (`0.5.0`).\n- `Version.API_SPEC_VERSION` — the version of the [Apify OpenAPI specification](https://docs.apify.com/api/openapi.json)\n  (its `info.version` field) that this client's endpoints, parameters and models were last generated\n  and checked against (`v2-2026-07-22T122437Z`). It is a snapshot, not a live compatibility\n  guarantee: the client keeps working against newer, backward-compatible spec revisions, but a\n  feature added to the API after this snapshot has no corresponding method here yet.\n\nChanges to the public interface other than additive ones are considered breaking changes and follow\n[Semantic Versioning](https://semver.org/).\n\n### Releasing\n\nReleases are published to Maven Central through the Sonatype Central Publisher Portal by the\nmanually-triggered `Publish Java client` GitHub Actions workflow. The workflow runs in the\nprotected `Publishing` GitHub environment and authenticates to the portal with the Maven Central\nrepository credentials held there, signs the artifacts with GPG, publishes the\n`com.apify:apify-client` artifact, and creates a tagged GitHub release. The release version is taken\nfrom the `\u003cversion\u003e` in `pom.xml`.\n\n## Scope\n\nThe client covers the documented Apify API endpoints that the JavaScript reference client exposes.\n\nFor cross-client parity, the following documented spec endpoints are intentionally **not**\nimplemented (the JS reference exposes none of them):\n\n- The synchronous run endpoints (`run-sync`, `run-sync-get-dataset-items`).\n- The cryptographic tools `POST /v2/tools/encode-and-sign` and `POST /v2/tools/decode-and-verify`\n  (this client performs the same HMAC-SHA256 URL signing locally).\n- `/v2/browser-info`.\n- The keyed-`POST` create variants that duplicate the covered `PUT` writes.\n\n## Documentation\n\nFull documentation is in the [`docs/`](docs/README.md) directory, organized by resource:\n\n- [Actors, versions \u0026 environment variables](docs/actors.md)\n- [Builds](docs/builds.md)\n- [Runs](docs/runs.md)\n- [Storages (datasets, key-value stores, request queues)](docs/storages.md)\n- [Tasks](docs/tasks.md)\n- [Schedules](docs/schedules.md)\n- [Webhooks \u0026 dispatches](docs/webhooks.md)\n- [Store, users \u0026 logs](docs/misc.md)\n- [Examples](docs/examples.md)\n\n## Resources\n\nEvery resource client lives in its own sub-package of `com.apify.client`, named after the resource.\n`ApifyClient` itself, its builder, the exception types, and shared value types (`PaginationList`,\n`Version`, ...) stay in the root `com.apify.client` package.\n\n| Accessor | Client | Package | Description |\n|---|---|---|---|\n| `actors()` / `actor(id)` | `ActorCollectionClient` / `ActorClient` | `com.apify.client.actor` | Actors |\n| `builds()` / `build(id)` | `BuildCollectionClient` / `BuildClient` | `com.apify.client.build` | Actor builds |\n| `runs()` / `run(id)` | `RunCollectionClient` / `RunClient` | `com.apify.client.run` | Actor runs |\n| `datasets()` / `dataset(id)` | `DatasetCollectionClient` / `DatasetClient` | `com.apify.client.dataset` | Datasets |\n| `keyValueStores()` / `keyValueStore(id)` | `KeyValueStoreCollectionClient` / `KeyValueStoreClient` | `com.apify.client.keyvalue` | Key-value stores |\n| `requestQueues()` / `requestQueue(id)` | `RequestQueueCollectionClient` / `RequestQueueClient` | `com.apify.client.requestqueue` | Request queues |\n| `tasks()` / `task(id)` | `TaskCollectionClient` / `TaskClient` | `com.apify.client.task` | Actor tasks |\n| `schedules()` / `schedule(id)` | `ScheduleCollectionClient` / `ScheduleClient` | `com.apify.client.schedule` | Schedules |\n| `webhooks()` / `webhook(id)` | `WebhookCollectionClient` / `WebhookClient` | `com.apify.client.webhook` | Webhooks |\n| `webhookDispatches()` / `webhookDispatch(id)` | `WebhookDispatchCollectionClient` / `WebhookDispatchClient` | `com.apify.client.webhook` | Webhook dispatches |\n| `store()` | `StoreCollectionClient` | `com.apify.client.store` | Apify Store |\n| `me()` / `user(id)` | `UserClient` | `com.apify.client.user` | Users |\n| `log(id)` | `LogClient` | `com.apify.client.log` | Build/run logs |\n| `setStatusMessage(message, options)` | — (direct `ApifyClient` method, no resource client) | `com.apify.client.run` (for `SetStatusMessageOptions`) | Sets the status message of the current Actor run (see [docs/README.md](docs/README.md#setting-the-current-runs-status-message)) |\n\nThe HTTP transport contract (`HttpTransport`, `DefaultHttpTransport`) and the exceptions thrown for\ntransport-level failures (`ApifyTransportException`, `HttpTimeoutException`) live in\n`com.apify.client.http`, alongside `ApifyApiException`.\n\n## License\n\n[Apache License 2.0](LICENSE).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fapify%2Fapify-client-java","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fapify%2Fapify-client-java","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fapify%2Fapify-client-java/lists"}