How do you handle networking and APIs in Flutter?

Question

IT Interview Practice · Accepted Answer

Flutter apps frequently communicate with **APIs** — making HTTP requests, parsing JSON, and handling responses/errors. Using the **http** or **dio** packages, **async/await**, and JSON parsing, networking is a core part of most apps. ## Making HTTP requests ```dart import 'package:http/http.dart' as http; // GET request Future> fetchUsers() async { final response = await http.get(Uri.parse('https://api.example.com/users')); if (response.statusCode == 200) { final List data = jsonDecode(response.body); // parse JSON return data.map((json) => User.fromJson(json)).toList(); } else { throw Exception('Failed to load users'); // handle errors } } // POST request await http.post( Uri.parse('https://api.example.com/users'), headers: {'Content-Type': 'application/json'}, body: jsonEncode({'name': 'Ann'}), ); ``` ## JSON parsing (serialization) ```dart // model class with fromJson/toJson (convert between JSON and Dart objects) class User { final String name; User(this.name); factory User.fromJson(Map json) => User(json['name']); Map toJson() => {'name': name}; } // → for many models, use code generation (json_serializable) to avoid boilerplate ``` ## Best practices ```text ✓ Use a SERVICE/repository layer (separate networking from UI) — clean architecture ✓ Handle ERRORS (network failures, non-200 status, timeouts) gracefully → show UI feedback ✓ Show LOADING states (FutureBuilder / state management) ✓ Use DIO for advanced needs (interceptors, retries, better config) vs basic http ✓ Parse JSON into typed MODELS (not raw maps) — type safety ✓ Handle auth (tokens in headers), timeouts, and cancellation ``` ## Why it matters Understanding networking and APIs in Flutter is essential because **most apps communicate with backends** — fetching and sending data over HTTP is a core part of nearly every real app, so it's must-know practical knowledge. Apps constantly need to make API calls (loading data, submitting forms, authentication), and understanding how to do this correctly is fundamental. Knowing how to **make HTTP requests** (GET, POST, etc. using the `http` or `dio` packages with async/await), **parse JSON** (converting API responses into typed Dart model objects via `fromJson`/`toJson`, ideally with code generation for many models), and **handle responses and errors** (checking status codes, throwing/handling exceptions) is the core practical skill. Understanding the **best practices** is particularly valuable: using a **service/repository layer** to separate networking from UI (clean architecture, maintainability), **handling errors gracefully** (network failures, non-200 statuses, timeouts — showing appropriate UI feedback, since network calls commonly fail), **showing loading states** (via FutureBuilder or state management, for good UX), parsing JSON into **typed models** (for type safety rather than raw maps), and handling auth and timeouts — these reflect building robust, maintainable networking code rather than fragile ad-hoc calls. Since most Flutter apps communicate with APIs (a near-universal need) and doing it well (proper requests, JSON parsing into models, error handling, loading states, and clean architecture) is essential for functional, robust apps, and since understanding the tools and best practices is necessary for this core capability, understanding networking and APIs in Flutter is essential, frequently-applied practical knowledge — a fundamental skill needed in virtually every real Flutter app that communicates with a backend, central to building apps that fetch and display real data reliably.

Making HTTP requests

JSON parsing (serialization)

Best practices

Why it matters

Related questions