Beginner's Guide to Flutter Networking with HTTP Package

Beginner's Guide to Flutter Networking with HTTP Package

What is Networking in flutter?

Networking in Flutter involves establishing and managing communication between a Flutter app and a remote server or API over the network. It encompasses tasks such as making HTTP requests, handling responses, sending and receiving data, and managing errors. Essentially, networking enables your Flutter app to interact with external services, retrieve data, and update information over the internet.

Here are some common networking tasks in Flutter:

  1. Making Authenticated Requests: When your app needs to access protected resources on a server, it can send authenticated requests by including authentication tokens or credentials.

  2. Parsing JSON in the Background: Many APIs return data in JSON format. Flutter allows you to parse this data efficiently, transforming it into usable objects within your app.

  3. Fetching Data from the Internet: Your app can retrieve data from external APIs, databases, or other web services. This data can be used to display information to users or perform other actions.

  4. Sending Data to the Internet: If your app collects user input or generates data, it can send that data to a server for processing or storage.

  5. Updating Data Over the Internet: Apps often need to update information on the server, such as saving user preferences, marking items as read, or modifying user profiles.

  6. Communicating with WebSockets: WebSockets allow real-time communication between the app and a server. They are useful for features like chat applications, live updates, and notifications.

Flutter provides a powerful and flexible framework for networking, enabling developers to implement various networking techniques and interact with web services efficiently.If you’re building a Flutter app that requires data exchange with external servers or APIs, understanding networking concepts is essential for a smooth user experience.

Certainly! When it comes to networking in Flutter, there are several popular libraries that can simplify making HTTP requests and handling network-related tasks. Here are some of the most widely used ones:

http :

  • Description: The http package is maintained by the Dart team and is one of the most-liked HTTP packages on

  • Features:

    • Provides a high-level API for making HTTP requests.

    • Supports retrying requests.

  • Sample Usage:

      import 'package:http/http.dart' as http;
      void sendPostRequest() async {
          try {
            void sendPostRequest() async {
              final url = Uri.parse('put your API here');
              final response = await, body: {
                'title': '[Your title]',
                'body': 'Your body',
              print('Response status: ${response.statusCode}');
              print('Response body: ${response.body}');
          } catch (e) {

    Libraries offer different features and capabilities, so choose the one that best fits your project’s requirements.

HTTP Package in Flutter for Networking and Data Parsing

Step 1: Setting Up a Flutter Project

  • Ensure that you have Flutter and Dart installed. If you haven’t already, follow the official Flutter installation guide.

  • Create a new Flutter project using the following command:

flutter create api_example

Step 2: Add the HTTP Package

  • To add the http package as a dependency, run the following command:
flutter pub add http


  • To make HTTP requests, add the http package to your pubspec.yaml file:
    sdk: flutter
  http: ^1.2.1

Step 3: Import the HTTP Package

  • Import the package in your Dart file:
import 'package:http/http.dart' as http;

Step 4: Make a Network Request

  • Use the http.get() method to fetch data from an API:
Future<http.Response> fetchPosts() {
  return http.get(Uri.parse('Put your API here'));

Step 5: Handle Authentication

  • For basic authentication, include the credentials in the request headers:
final url = Uri.parse('Put your API here');
final response = await http.get(url, headers: {
  'Authorization': 'Basic your_base64_encoded_credentials',
  • For token-based authentication, set the token in the request headers:
final token = 'your_access_token';
final response = await http.get(url, headers: {
  'Authorization': 'Bearer $token',

Step 6: Parse the Response

  • Convert the response into a Dart object. Create a class that represents the data from the network request:
class PostModel {
  final int userId;
  final String title;
  final String body;
    required this.userId,
    required this.title,
    required this.body,
  factory PostModel.fromJson(Map<String, dynamic> json) {
    return PostModel(
      userId: json['userId'] as int,
      title: json['title'] as String,
      body: json['body'] as String,
  Map<String, dynamic> toJson() {
    return {
      'userId': userId,
      'title': title,
      'body': body,

Step 7: Display the Data

  • In your widget tree, wrap the part where you want to display the data with a FutureBuilder.

  • Set the future parameter of FutureBuilder to the function that fetches the data (in this case, fetchPosts()).

  • The builder callback will be called with the data once it’s available. You can use this data to build your UI.

FutureBuilder<List<Map<String, dynamic>>>(
  future: fetchPosts(),
  builder: (context, snapshot) {
    if (snapshot.connectionState == ConnectionState.waiting) {
      // While waiting for data, show a loading indicator
      return CircularProgressIndicator();
    } else if (snapshot.hasError) {
      // If there's an error, display an error message
      return Text('Error loading data');
    } else if (snapshot.hasData) {
      // If data is available, display the posts
      final posts =;
      return ListView.builder(
        itemCount: posts.length,
        itemBuilder: (context, index) {
          final post = posts[index];
          return ListTile(
            title: Text(post['title']),
            subtitle: Text(post['body']),
    } else {
      // If none of the above conditions apply, show a fallback
      return Text('No data available');

Step 8: Error Handling

  • Test your network requests thoroughly, handle errors, and ensure graceful handling of exceptions. If the status code is not 200 (OK), throw an exception:

if (response.statusCode == 200) {
  // If the server returns a 200 OK response, parse the JSON.
  return PostModel.toJson(jsonDecode(response.body));
} else {
  // If the server did not return a 200 OK response, throw an exception.
  throw Exception('Failed to load album');

Some common http status code

Certainly! HTTP status codes are three-digit numbers returned by a server in response to a client’s request. They provide information about the outcome of the request. Here are some common HTTP status codes:

  1. 1xx (Informational):

    • These codes indicate that the request has been received and the server is continuing to process it.

    • Example: 100 Continue means the client can continue with the request.

  2. 2xx (Successful):

    • These codes indicate that the request was successfully received, understood, and processed.

    • Examples:

      • 200 OK: The request was successful.

      • 201 Created: A new resource was successfully created.

  3. 3xx (Redirection):

    • These codes indicate that further action is needed to complete the request.

    • Examples:

      • 301 Moved Permanently: The requested resource has been permanently moved to a different location.

      • 302 Found: The requested resource has been temporarily moved to a different location.

  4. 4xx (Client Errors):

    • These codes indicate that the client (usually the browser or user agent) made an error.

    • Examples:

      • 400 Bad Request: The request was malformed or invalid.

      • 404 Not Found: The requested resource was not found on the server.

  5. 5xx (Server Errors):

    • These codes indicate that the server encountered an error while processing the request.

    • Examples:

      • 500 Internal Server Error: A generic server error occurred.

      • 503 Service Unavailable: The server is temporarily unable to handle requests.

Remember that these are just a few examples, and there are many other status codes with specific meanings. When working with APIs or web services, understanding these status codes is crucial for handling responses effectively.

Mastering networking in Flutter with the HTTP package is crucial for efficient communication between apps and servers. Understanding networking concepts, utilising the HTTP package for requests, handling authentication, parsing data, and managing errors are key for creating robust Flutter applications. Happy coding and networking in Flutter!

Did you find this article valuable?

Support JoFlee by becoming a sponsor. Any amount is appreciated!