http

https://pub.dev/packages/http
Admin
A composable, multi-platform, Future-based API for making HTTP requests, supporting mobile, desktop,...
Tokens:5,550
Snippets:111
Trust Score:9.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Make HTTP GET Request and Decode JSON

Source: https://pub.dev/packages/http/example

This example demonstrates how to fetch data from the Google Books API using an HTTP GET request. It shows how to handle the response, check the status code, and decode the JSON response body. Ensure the http package is imported.

```dart
import 'dart:convert' as convert;

import 'package:http/http.dart' as http;

void main(List<String> arguments) async {
  // This example uses the Google Books API to search for books about http.
  // https://developers.google.com/books/docs/overview
  var url =
      Uri.https('www.googleapis.com', '/books/v1/volumes', {'q': '{http}'});

  // Await the http get response, then decode the json-formatted response.
  var response = await http.get(url);
  if (response.statusCode == 200) {
    var jsonResponse =
        convert.jsonDecode(response.body) as Map<String, dynamic>;
    var itemCount = jsonResponse['totalItems'];
    print('Number of books about http: $itemCount.');
  } else {
    print('Request failed with status: ${response.statusCode}.');
  }
}
```

--------------------------------

### Make Simple HTTP Requests

Source: https://pub.dev/packages/http

Use top-level functions for making individual HTTP requests with minimal setup. Suitable for one-off requests.

```dart
import 'package:http/http.dart' as http;

var url = Uri.https('example.com', 'whatsit/create');
var response = await http.post(url, body: {'name': 'doodle', 'color': 'blue'});
print('Response status: ${response.statusCode}');
print('Response body: ${response.body}');

print(await http.read(Uri.https('example.com', 'foobar.txt')));

```

--------------------------------

### Configure Platform-Specific HTTP Client

Source: https://pub.dev/packages/http

Provides a function to return a configured `Client` based on the platform. Includes examples for Android (Cronet), iOS/macOS (Cupertino), and a default IOClient.

```dart
Client httpClient() {
  if (Platform.isAndroid) {
    final engine = CronetEngine.build(
        cacheMode: CacheMode.memory,
        cacheMaxSize: 1000000);
    return CronetClient.fromCronetEngine(engine);
  }
  if (Platform.isIOS || Platform.isMacOS) {
    final config = URLSessionConfiguration.ephemeralSessionConfiguration()
      ..cache = URLCache.withCapacity(memoryCapacity: 1000000);
    return CupertinoClient.fromSessionConfiguration(config);
  }
  return IOClient();
}

```

--------------------------------

### Implement Custom HTTP Client

Source: https://pub.dev/packages/http

Extend http.BaseClient to add custom behavior, such as setting headers, to HTTP requests. This example adds a User-Agent header.

```dart
class UserAgentClient extends http.BaseClient {
  final String userAgent;
  final http.Client _inner;

  UserAgentClient(this.userAgent, this._inner);

  @override
  Future<http.StreamedResponse> send(http.BaseRequest request) {
    request.headers['user-agent'] = userAgent;
    return _inner.send(request);
  }
}

```

--------------------------------

### Import HTTP Package in Dart Code

Source: https://pub.dev/packages/http/install

Import the HTTP package into your Dart files to start making HTTP requests.

```dart
import 'package:http/http.dart';
```

--------------------------------

### Configure HTTP Client for Browser and Native

Source: https://pub.dev/packages/http

Demonstrates separating browser and native HTTP client configurations into different files and importing the correct one based on the platform.

```dart
// -- http_client_factory.dart
Client httpClient() {
  if (Platform.isAndroid) {
    return CronetClient.defaultCronetEngine();
  }
  if (Platform.isIOS || Platform.isMacOS) {
    return CupertinoClient.defaultSessionConfiguration();
  }
  return IOClient();
}

```

```dart
// -- http_client_factory_web.dart
Client httpClient() => FetchClient();

```

```dart
// -- main.dart
import 'http_client_factory.dart'
    if (dart.library.js_interop) 'http_client_factory_web.dart'

// The correct `httpClient` will be available.

```

--------------------------------

### Connect HTTP Client via Arguments

Source: https://pub.dev/packages/http

Shows how to explicitly pass the configured `Client` instance as an argument to functions that require it, such as `fetchAlbum`.

```dart
void main() {
  final client = httpClient();
  fetchAlbum(client, ...);
}

```

--------------------------------

### Testing with MockClient

Source: https://pub.dev/packages/http

Demonstrates how to mock the HTTP client using `package:http/testing.dart` for unit tests. This allows you to simulate responses and verify behavior.

```dart
import 'package:http/testing.dart';
import 'package:test/test.dart';

void main() {
  test('fetchData returns expected data', () async {
    final mockClient = MockClient((request) async {
      return http.Response('{"key": "value"}', 200);
    });

    final dataService = DataService(client: mockClient);
    final result = await dataService.fetchData();

    expect(result, '{"key": "value"}');
  });
}
```

--------------------------------

### Build App with No Default HTTP Client

Source: https://pub.dev/packages/http

Demonstrates how to build an application (Flutter or Dart CLI) with the default HTTP client removed by setting the `no_default_http_client` flag.

```bash
$ flutter build appbundle --dart-define=no_default_http_client=true ...
$ dart compile exe --define=no_default_http_client=true ...

```

--------------------------------

### Accepting an Explicit Client Argument

Source: https://pub.dev/packages/http

Demonstrates how to accept an explicit `Client` argument in a function, allowing the caller to provide a specific HTTP client implementation. If no client is provided, it defaults to a new `Client` instance.

```dart
Future<Album> fetchAlbum({Client? client}) async {
  client ??= Client();
  ...
}
```

--------------------------------

### Add Flutter HTTP Client Dependency

Source: https://pub.dev/packages/http

Use `flutter pub add` to include a compatible HTTP client package for the Flutter SDK.

```bash
# Replace  "cupertino_http" with the package that you want to use.
flutter pub add cupertino_http

```

--------------------------------

### Add Dart HTTP Client Dependency

Source: https://pub.dev/packages/http

Use `dart pub add` to include a compatible HTTP client package for the Dart SDK.

```bash
# Replace  "fetch_client" with the package that you want to use.
dart pub add fetch_client

```

--------------------------------

### Use Persistent HTTP Client

Source: https://pub.dev/packages/http

Instantiate an http.Client to maintain a persistent connection for multiple requests to the same server. Ensure the client is closed when no longer needed.

```dart
var client = http.Client();
try {
  var response = await client.post(
      Uri.https('example.com', 'whatsit/create'),
      body: {'name': 'doodle', 'color': 'blue'});
  var decodedResponse = jsonDecode(utf8.decode(response.bodyBytes)) as Map;
  var uri = Uri.parse(decodedResponse['uri'] as String);
  print(await client.get(uri));
} finally {
  client.close();
}

```

--------------------------------

### Add HTTP Package to Flutter Project

Source: https://pub.dev/packages/http/install

Use this command to add the HTTP package as a dependency in your Flutter project.

```bash
$ flutter pub add http
```

--------------------------------

### Mocking HTTP Client for Testing

Source: https://pub.dev/packages/http

Use a Client instance for better testability in Flutter applications. This allows for easy mocking of HTTP requests in tests.

```dart
class DataService {
  final http.Client client;

  DataService({http.Client? client}) : client = client ?? http.Client();

  Future<String> fetchData() async {
    var response = await client.get(Uri.https('example.com', 'data.json'));
    return response.body;
  }
}
```

--------------------------------

### Add HTTP Package to Dart Project

Source: https://pub.dev/packages/http/install

Use this command to add the HTTP package as a dependency in your Dart project.

```bash
$ dart pub add http
```

--------------------------------

### Retrying HTTP Requests with RetryClient

Source: https://pub.dev/packages/http

Utilizes `package:http/retry.dart`'s `RetryClient` to automatically retry failing HTTP requests. This client wraps an underlying `http.Client` and handles transient errors.

```dart
import 'package:http/http.dart' as http;
import 'package:http/retry.dart';

Future<void> main() async {
  final client = RetryClient(http.Client());
  try {
    print(await client.read(Uri.http('example.org', '')));
  } finally {
    client.close();
  }
}
```

--------------------------------

### Abort HTTP Request with AbortableRequest

Source: https://pub.dev/packages/http

Use `AbortableRequest` with a `Completer`'s future for the `abortTrigger`. If the request is aborted before completion, `RequestAbortedException` is thrown. This applies to both the initial request send and when consuming the `StreamedResponse`.

```dart
import 'dart:async';

import 'package:http/http.dart' as http;

Future<void> main() async {
  final abortTrigger = Completer<void>();
  final client = Client();
  final request = AbortableRequest(
    'GET',
    Uri.https('example.com'),
    abortTrigger: abortTrigger.future,
  );

  // Whenever abortion is required:
  // > abortTrigger.complete();

  // Send request
  final StreamedResponse response;
  try {
    response = await client.send(request);
  } on RequestAbortedException {
    // request aborted before it was fully sent
    rethrow;
  }

  // Using full response bytes listener
  response.stream.listen(
    (data) {
      // consume response bytes
    },
    onError: (Object err) {
      if (err is RequestAbortedException) {
        // request aborted whilst response bytes are being streamed;
        // the stream will always be finished early
      }
    },
    onDone: () {
      // response bytes consumed, or partially consumed if finished
      // early due to abortion
    },
  );

  // Alternatively, using `asFuture`
  try {
    await response.stream.listen(
      (data) {
        // consume response bytes
      },
    ).asFuture<void>();
  } on RequestAbortedException {
    // request aborted whilst response bytes are being streamed
    rethrow;
  }
    // response bytes fully consumed
}
```
Tokens:
Raw