How to Use java.net.URLConnection for HTTP Requests in Java

By the end of this page, you will understand how Java's URLConnection and, more specifically, HttpURLConnection are used for HTTP communication. You will learn how to send GET and POST requests, add headers, read status codes and response headers, submit form data, upload files, and manage cookies in a beginner-friendly way.

URLConnection is Java's general-purpose API for communicating with resources identified by a URL. When that URL uses the http or https protocol, the actual object is usually an instance of HttpURLConnection.

That distinction matters:

• URLConnection is the base class for many kinds of connections.
• HttpURLConnection adds HTTP-specific features such as:
  • request method (GET, POST, etc.)
  • response status code
  • redirects
  • HTTP headers

In real programs, you usually create a URL, open a connection, cast it to HttpURLConnection, configure the request, optionally write a request body, then read the response.

A typical HTTP exchange in Java involves these steps:

1. Create a URL
2. Open the connection
3. Cast to HttpURLConnection
4. Set request method and headers
5. If needed, enable output and write request data
6. Read the response code
7. Read the response body or error body
8. Close streams and disconnect

This matters because most applications talk to APIs, web services, login systems, file upload endpoints, or external platforms over HTTP. Understanding this low-level API helps you understand what higher-level libraries are doing under the hood.

Think of HttpURLConnection like filling out and sending a postal package:

• The URL is the destination address.
• The request method (GET, POST) is the type of service you choose.
• Headers are labels on the package, such as content type or authorization.
• The request body is the item you put inside the package.
• The response code is the delivery result.
• The response headers are metadata returned by the receiver.
• The response body is the message sent back.

If you only do a GET, you are basically asking, "Please send me the information at this address." If you do a POST, you are sending data along with the request.

Basic GET request

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class GetExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://api.example.com/users");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "application/json");

        int status = connection.getResponseCode();
        System.out.println("Status: " + status);

        BufferedReader reader = new BufferedReader(
            new InputStreamReader(connection.getInputStream())
        );

        String line;
        StringBuilder response   ();
         ((line = reader.readLine()) != ) {
            response.append(line);
        }
        reader.close();

        System.out.println(response);
        connection.disconnect();
    }
}

Example: sending form data

URL url = new URL("https://example.com/login");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
connection.setDoOutput(true);

String body = "email=test%40example.com&password=abc123";

try (OutputStream os = connection.getOutputStream()) {
    os.write(body.getBytes(StandardCharsets.UTF_8));
}

int status = connection.getResponseCode();

What happens step by step

1. new URL(...)

   • Creates a URL object that points to the target endpoint.

2. url.openConnection()

   • Opens a connection object for that URL.
   • Because the URL uses HTTP or HTTPS, the object is really an HttpURLConnection.

Common places this is used

• Calling REST APIs

  • Send GET requests to fetch users, orders, or reports.
  • Send POST requests to create new records.

• Logging into a service

  • Submit username and password as form data or JSON.

• Sending authentication headers

  • Add tokens using Authorization headers.

• Submitting HTML forms

  • Use application/x-www-form-urlencoded for simple forms.
  • Use multipart/form-data for file uploads.

• Reading API metadata

  • Check content type, rate limit headers, cache headers, or cookies.

• Downloading files

  • Read bytes from the input stream and save them locally.

• Working with session-based systems

  • Read cookies from login responses and send them on later requests.

In real projects, developers often wrap HttpURLConnection in helper methods so the rest of the application does not deal with repetitive setup code.

Common patterns

Guard clauses for status codes

int status = connection.getResponseCode();
if (status < 200 || status >= 300) {
    throw new RuntimeException("Request failed with status: " + status);
}

This quickly stops processing when the server returns an error.

Reading the error stream

InputStream stream = status >= 400
    ? connection.getErrorStream()
    : connection.getInputStream();

Servers often send useful error details in the error stream.

Validation before sending requests

Developers often validate inputs before building the request:

• ensure required fields are present
• avoid null tokens
• confirm file paths exist before upload

Helper methods

A codebase might have methods like:

• sendGet(String url)

1. Using URLConnection when you need HTTP-specific features

Broken idea:

URLConnection connection = url.openConnection();
connection.setRequestProperty("Accept", "application/json");
// Cannot access HTTP status code directly here

Use HttpURLConnection when working with HTTP:

HttpURLConnection connection = (HttpURLConnection) url.openConnection();

2. Forgetting setDoOutput(true) for POST bodies

Broken code:

connection.setRequestMethod("POST");
OutputStream os = connection.getOutputStream();

Safer version:

connection.setRequestMethod("POST");
connection.setDoOutput(true);

3. Not encoding form data properly

Broken code:

Quick reference

Open a connection

URL url = new URL("https://example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();

Set request method

connection.setRequestMethod("GET");
connection.setRequestMethod("POST");

Set headers

connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("Content-Type", "application/json; charset=UTF-8");

Send a request body

connection.setDoOutput(true);
try (OutputStream os = connection.getOutputStream()) {
    os.write(dataBytes);
}

Read response code

int status = connection.getResponseCode();

When should I use HttpURLConnection instead of URLConnection?

Use HttpURLConnection when the URL is HTTP or HTTPS and you need HTTP-specific features like methods, status codes, and headers.

How do I send JSON with HttpURLConnection?

Set Content-Type to application/json; charset=UTF-8, call setDoOutput(true), and write the JSON string to the output stream.

How do I submit an HTML form in Java?

For simple text fields, send URL-encoded data with application/x-www-form-urlencoded. For file uploads, use multipart/form-data.

How do I read HTTP response headers in Java?

Use getHeaderField("Header-Name") for one header or getHeaderFields() for all headers.

How do I handle cookies with HttpURLConnection?

Use a CookieManager with CookieHandler.setDefault(...) so cookies can be stored and reused across requests.

Why does fail on some requests?

• HttpURLConnection — the HTTP-specific subclass of URLConnection
• URL — represents the address you connect to
• InputStream and OutputStream — used to read responses and write request bodies
• HTTP request methods — such as GET, POST, PUT, and DELETE
• HTTP headers — metadata for requests and responses
• URLEncoder — encodes form values safely for URLs and form bodies
• cookies and sessions — useful for login flows and stateful requests
• JSON in Java — common format for API request and response bodies
• multipart form data — required for file uploads
• Java 11 HttpClient — a newer alternative for HTTP requests in modern Java