
Baeldung Pro comes with both absolutely No-Ads as well as finally with Dark Mode, for a clean learning experience:
Once the early-adopter seats are all used, the price will go up and stay at $33/year.
Last updated: May 4, 2025
In this tutorial, we’ll explore several ways to determine whether a file is a PDF in Java, using an approach without third-party dependencies and with different libraries.
The file signature is also known as the magic number. It’s a sequence of bytes at the beginning of the file that determines the file type.
The PDF file signature contains 25 50 44 46 2D in hexadecimal. We can encode it as an ASCII String “%PDF-“.
In this and the following sections, we’ll use the following constant that contains our PDF file to run the tests:
final File PDF_FILE = new File("src/test/resources/input.pdf");
We extract the first five bytes of the file and match them with this file signature to identify whether it’s a PDF:
@Test
void whenDetectPdfByFileSignature_thenCorrect() throws IOException {
boolean isPdf = false;
try (InputStream fis = new BufferedInputStream(new FileInputStream(PDF_FILE))) {
byte[] bytes = new byte[5];
if (fis.read(bytes) == 5) {
String header = new String(bytes);
isPdf = Objects.equals(header, "%PDF-");
}
}
assertTrue(isPdf);
}
As we can see, only the first few bytes are required for the detection. Hence, it’s a lightweight approach, and we don’t need any third-party dependencies.
If we prefer using third-party dependencies instead of coding the detection ourselves, we could have the following three different choices. Internally, all of them also rely on the file signature for detection.
Apache Tika is an open-source toolkit providing a single interface for detecting various file types, including PDF. It’s handy if we need to perform multiple file type identifications in our application.
Let’s include the following Maven dependency in our pom.xml:
<dependency>
<groupId>org.apache.tika</groupId>
<artifactId>tika-core</artifactId>
<version>3.1.0</version>
</dependency>
In this example, we simply call the detect() method to find out the MIME type of our file and consider the file a PDF if it’s application/pdf:
@Test
void whenDetectPdfByTika_thenCorrect() throws IOException {
Tika tika = new Tika();
boolean isPdf = Objects.equals(tika.detect(PDF_FILE), "application/pdf");
assertTrue(isPdf);
}
Apache PDFBox is one of the prevalent open-source Java libraries for manipulating PDF files programmatically.
Let’s include the following Maven dependency in our pom.xml:
<dependency>
<groupId>org.apache.pdfbox</groupId>
<artifactId>pdfbox</artifactId>
<version>3.0.4</version>
</dependency>
We use the Loader class to parse the PDF file. It throws an IOException if the file isn’t a valid PDF:
@Test
void whenDetectPdfByPdfBox_thenCorrect() throws IOException {
boolean isPdf;
try (PDDocument document = Loader.loadPDF(PDF_FILE)) {
isPdf = true;
} catch (IOException ioe) {
isPdf = false;
}
assertTrue(isPdf);
}
Since PDDocument holds system resources, we must ensure it’s closed after using it to avoid a memory leak. This can be handled using a try-with-resources block, which closes resources that implement the Closable interface.
iText is another open-source Java library for manipulating PDF files programmatically.
We include the following Maven dependency to use iText:
<dependency>
<groupId>com.itextpdf</groupId>
<artifactId>itext7-core</artifactId>
<version>7.2.4</version>
</dependency>
We determine the file type by reading the file as a PdfDocument. PdfReader throws an ITextException if the file isn’t a valid PDF:
@Test
void whenDetectPdfByItext_thenCorrect() {
boolean isPdf;
try (PdfDocument pdfDoc = new PdfDocument(new PdfReader(PDF_FILE))) {
isPdf = true;
} catch (ITextException | IOException e) {
isPdf = false;
}
assertTrue(isPdf);
}
Both Apache PDFBox and iText can detect the PDF file type, and they also read the whole document. They’re usually overkill if we only want to detect the file type, rather than manipulating it. A lightweight approach is always preferred in such scenarios.
In this article, we explored different ways of determining whether a file is a PDF.
Apache PDFBox and iText are the best for us if we require manipulating the PDF as well. If we’re concerned with the file types only, we can either verify the PDF file signature or use Apache Tika to avoid reading the whole PDF file.
As always, complete code examples are available over on GitHub.