​​​ ​
​ ​
​ ​
​​
The easiest HTTP networking library for Kotlin/Android.
You are looking at the documentation for 2.x.y.. If you are looking for the documentation for 1.x.y, checkout the 1.16.0 README.md​
HTTP GET
/POST
/PUT
/DELETE
/HEAD
/PATCH
requests in a fluent style interface
Asynchronous and blocking requests
Download as a file
Upload files, Blob
s, DataPart
s as multipart/form-data
Cancel asynchronous request
Debug logging / convert to cUrl call
Deserialization into POJO / POKO
Requests as coroutines​
API Routing
We offer maven and jitpack installations. Maven via bintray only has stable releases but jitpack can be used to build any branch, commit and version.
You can download and install Fuel
with Maven
and Gradle
. The core package has the following dependencies:
//coreimplementation 'com.github.kittinunf.fuel:fuel:<latest-version>'​//packagesimplementation 'com.github.kittinunf.fuel:<package>:<latest-version>'
Make sure to include jcenter()
or mavenCentral()
in your repositories
repositories {jcenter() //or mavenCentral()}
Each of the extensions / integrations has to be installed separately.
Package | Description |
​ | Core package |
​ | Android: Automatically invoke handler on Main Thread when using Android Module |
​ | KotlinX: Execution with coroutines​ |
​ | Deserialization: |
​ | (De)serialization: |
​ | Deserialization: |
​ | Deserialization: |
(De)serialization: | |
​ | Android Architectures: Responses as |
​ | Deserialization: |
​ | Reactive Programming: Responses as |
​ | Reactive Programming: Responses as |
​ | Utility: Debug utility for Android on Chrome Developer Tools, |
If you want a SNAPSHOT distribution, you can use Jitpack
​
repositories {maven(url = "https://www.jitpack.io") {name = "jitpack"}}​dependencies {//coreimplementation(group = "com.github.kittinunf.fuel", name = "fuel", version = "-SNAPSHOT")​//packages// replace <package> with the package name e.g. fuel-coroutinesimplementation(group = "com.github.kittinunf.fuel", name = "<package>", version = "-SNAPSHOT")}
or
dependencies {//core and/or packages// replace <package> with the package name e.g. fuel-coroutineslistof("fuel", "<package>").forEach {implementation(group = "com.github.kittinunf.fuel", name = it, version = "-SNAPSHOT")}}
group
is made up of com.github
as well as username and project name
name
is the subproject, this may be any of the packages listed in the installation instructions eg. fuel
, fuel-coroutines
, fuel-kotlinx-serialization
, etc
version
can be the latest master-SMAPSHOT
or -SNAPSHOT
which always points at the HEAD or any other branch, tag or commit hash, e.g. as listed on jitpack.io.
We recommend not using SNAPSHOT
builds, but a specific commit in a specific branch (like a commit on master), because your build will then be stable.
Have patience when updating the version of fuel or building for the first time as jitpack will build it, and this may cause the request to jitpack to time out. Wait a few minutes and try again (or check the status on jitpack).
NOTE: do not forget to add the kotlinx
repository when using coroutines
or serialization
Jitpack.io also allows to build from fuel
forks. If a fork's username is $yourname
,
adjust group
to com.github.$yourName.fuel
and look for version
on https://jitpack.io/#$yourName/Fuel
Fuel requests can be made on the Fuel
namespace object, any FuelManager
or using one of the String
extension methods. If you specify a callback the call is async
, if you don't it's blocking
.
import com.github.kittinunf.fuel.httpGetimport com.github.kittinunf.result.Result​fun main(args: Array<String>) {​val httpAsync = "https://httpbin.org/get".httpGet().responseString { request, response, result ->when (result) {is Result.Failure -> {val ex = result.getException()println(ex)}is Result.Success -> {val data = result.get()println(data)}}}​httpAsync.join()}
import com.github.kittinunf.fuel.httpGetimport com.github.kittinunf.result.Result;​fun main(args: Array<String>) {​val (request, response, result) = "https://httpbin.org/get".httpGet().responseString()​when (result) {is Result.Failure -> {val ex = result.getException()println(ex)}is Result.Success -> {val data = result.get()println(data)}}​}​// You can also use Fuel.get("https://httpbin.org/get").responseString { ... }// You can also use FuelManager.instance.get("...").responseString { ... }
Fuel
and the extension methods use the FuelManager.instance
under the hood. You can use this FuelManager to change the default behaviour of all requests:
FuelManager.instance.basePath = "https://httpbin.org"​"/get".httpGet().responseString { request, response, result -> /*...*/ }// This is a GET request to "https://httpbin.org/get"
Check each of the packages documentations or the Wiki for more features, usages and examples. Are you looking for basic usage on how to set headers, authentication, request bodies and more? fuel
: Basic usage is all you need.
​fuel
: Basic usage​
If you like Fuel, you might also like other libraries of mine;
​Result - The modelling for success/failure of operations in Kotlin
​Fuse - A simple generic LRU memory/disk cache for Android written in Kotlin
​Forge - Functional style JSON parsing written in Kotlin
​ReactiveAndroid - Reactive events and properties with RxJava for Android SDK
Fuel is brought to you by contributors.
Fuel is released under the MIT license.