> For the complete documentation index, see [llms.txt](https://docs.apryse.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.apryse.com/core/basic-operations/extraction/image-extract.md).

# Extracting images from a PDF on Server/Desktop

Learn how to extract image content from a PDF document with full code samples and various approaches. Understand PDF page content structure and how to traverse graphical elements efficiently. Master P

To extract image content from a PDF document.

{% tabs %}
{% tab title="C#" %}
{% code lineNumbers="true" %}

```csharp
PDFDoc doc = new PDFDoc(filename);
ElementReader reader = new ElementReader();

//  Read page content on every page in the document
for (PageIterator itr=doc.GetPageIterator(); itr.HasNext(); itr.Next())
{
  // Read the page
  reader.Begin(itr.Current());
  ProcessElements(reader);
  reader.End();
}

void ProcessElements(ElementReader reader)
{
  Element element;

  // Traverse the page display list
  while ((element = reader.Next()) != null)
  {
    switch (element.GetType())
    {
      case Element.Type.e_image:
      {
        pdftron.PDF.Image image = new pdftron.PDF.Image(element.GetXObject());
        image.Export(output_filename);  // or ExporAsPng() or ExporAsTiff()
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using element.GetImageData()
      }
      break;
      case Element.ElementType.e_form:
      {
        reader.FormBegin();
        ProcessElements(reader);
        reader.End();
        break;
      }
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="C++" %}
{% code lineNumbers="true" %}

```cpp
PDFDoc doc(filename);
ElementReader reader;

//  Read page content on every page in the document
PageIterator itr;
for (itr=doc.GetPageIterator(); itr.HasNext(); itr.Next())
{
  // Read the page
  reader.Begin(itr.Current());
  ProcessElements(reader);
  reader.End();
}

void ProcessElements(ElementReader reader)
{
  Element element;

  // Traverse the page display list
  while ((element = reader.Next()) != null)
  {
    switch (element.GetType())
    {
      case Element::e_image:
      {
        Image image(element.GetXObject());
        image.Export(output_filename); // or ExportAsTiff or ExportAsPng
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using element.GetImageData()				
      }
      case Element::e_form:
      {
        reader.FormBegin();
        ProcessElements(reader);
        reader.End();
        break;
      }
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="Go" %}
{% code lineNumbers="true" %}

```go
doc := NewPDFDoc(filename)
reader := NewElementReader()

//  Read page content on every page in the document
itr := doc.GetPageIterator()
for itr.HasNext(){
  page := itr.Current()
  reader.Begin(page)
  ProcessElements(reader)
  reader.End()
  itr.Next()
}

func ProcessElements(reader ElementReader){
  element := reader.Next()

  // Traverse the page display list
  for element.GetMp_elem().Swigcptr() != 0{
    etype := element.GetType()
    if etype == ElementE_image{
      image := NewImage(element.GetXObject())
      image.Export(output_filename) // or ExportAsTiff or ExportAsPng
      // optionally, you can also extract uncompressed/compressed 
      // image data directly using element.GetImageData()		

    }else if etype == ElementE_form {
      reader.FormBegin()
      ProcessElements(reader)
      reader.End()
    }
    element = reader.Next()
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="Java" %}
{% code lineNumbers="true" %}

```java
PDFDoc doc = new PDFDoc(filename);
ElementReader reader = new ElementReader();

//  Read page content on every page in the document
for (PageIterator itr=doc.getPageIterator(); itr.hasNext(); itr.next())
{
  // Read the page
  reader.begin(itr.current());
  ProcessElements(reader);
  reader.end();
}

void ProcessElements(ElementReader reader)
{
  Element element;

  // Traverse the page display list
  while ((element = reader.next()) != null)
  {
    switch (element.getType())
    {
      case Element.e_image:
      {
        Image image = new Image(element.getXObject());
        image.export(output_filename); // or exportAsTiff or exportAsPng
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using element.getImageData()
      }
      case Element.ElementType.e_form:
      {
        reader.formBegin();
        ProcessElements(reader);
        reader.end();
        break;
      }
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="JavaScript" %}
{% code lineNumbers="true" %}

```js
async function main() {
  const doc = await PDFNet.PDFDoc.createFromURL(filename);
  const reader = await PDFNet.ElementReader.create();

  //  Read page content on every page in the document
  const itr = await doc.getPageIterator();
  for (itr; await itr.hasNext(); itr.next())
  {
    // Read the page
    const page = await itr.current();
    reader.beginOnPage(page);
    await ProcessElements(reader);
    reader.end();
  }

  async function ProcessElements(reader)
  {
    // Traverse the page display list
    for (let element = await reader.next(); element !== null; element = await reader.next()) {
      const elementType = await element.getType();
      switch (elementType)
      {
        case PDFNet.Element.Type.e_image:
        {
          const image = await PDFNet.Image.createFromObj(await element.getXObject());
          image.export(output_filename); // or exportAsTiff or exportAsPng
          // optionally, you can also extract uncompressed/compressed 
          // image data directly using element.getImageData()
        }
        case PDFNet.Element.Type.e_form:
        {
          reader.formBegin();
          ProcessElements(reader);
          reader.end();
          break;
        }
      }
    }
  }
}
PDFNet.runWithCleanup(main);
```

{% endcode %}
{% endtab %}

{% tab title="Kotlin" %}
{% code lineNumbers="true" %}

```kotlin
val doc = PDFDoc(filename)
val reader = ElementReader()

//  Read page content on every page in the document
val itr = doc.pageIterator()
while (itr.hasNext())
{
  // Read the page
  reader.begin(itr.current())
  ProcessElements(reader)
  reader.end()
  itr.Next()
}

fun ProcessElements(reader: ElementReader)
{
  // Traverse the page display list
  var element = reader.next()
  while (element != null)
  {
    when (element.type)
    {
      Element.e_image -> {
        val image = Image(element.xObject)
        image.export(output_filename) // or exportAsTiff or exportAsPng
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using element.getImageData()
      }
      Element.e_form -> {
        reader.formBegin()
        ProcessElements(reader)
        reader.end()
      }
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="Obj-C" %}
{% code lineNumbers="true" %}

```objc
PTPDFDoc *doc = [[PTPDFDoc alloc] initWithFilepath: filename];
PTElementReader *reader = [[PTElementReader alloc] init];

for (PageIterator *itr=[doc GetPageIterator: 1]; [itr HasNext]; [itr Next])
{
  // Read the page
  [reader Begin: [itr Current]];
  ProcessElements(reader);
  [reader End];
}

void ProcessElements(PTElementReader *reader)
{
  // Traverse the page display list
  PTElement *element;	
  while ((element = [reader Next]))
  {
    switch ([element GetType])
    {	
      case e_ptimage:
      {
        PTImage *image = [[PTImage alloc] initWithImage_xobject: [element GetXObject]];
        [image ExportToFile: output_filepath]; // or ExportAsTiffFile or ExportAsPngFile
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using [element GetImageData]
      }
      case e_ptform:
      {
        [reader FormBegin];
        ProcessElements(reader);
        [reader End];
        break;
      } 
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="Swift" %}
{% code lineNumbers="true" %}

```swift
let doc: PTPDFDoc = PTPDFDoc(filepath: filename)
let reader: PTElementReader = PTElementReader()

let itr: PTPageIterator = doc.getPageIterator(1)
while itr.hasNext()
{
  // Read the page
  reader.begin(itr.current())
  ProcessElements(reader)
  reader.end()
  itr.next()
}

func ProcessElements(reader: PTElementReader)
{
  // Traverse the page display list
  while let element = reader.next()
  {
    switch element.getType()
    {
      case e_ptimage:
        let image: PTImage = PTImage(image_xobject: element.getXObject())
        image.export(toFile: output_filename) // or export(asTiffFile) or export(asPngFile)
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using element.getImageData()
      default:
        reader.formBegin()
        ProcessElements(reader)
        reader.end()
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="PHP" %}
{% code lineNumbers="true" %}

```php
$doc = new PDFDoc($filename);
$reader = new ElementReader();

for ($itr = $doc->GetPageIterator(); $itr->HasNext(); $itr->Next())	
{
  // Read the page
  $reader->Begin($itr->Current());
  ProcessElements($reader);
  $reader->End();
}

function ProcessElements($reader)
{
  // Traverse the page display list
  while (($element = $reader->Next()) != null)
  {
    switch ($element->GetType())
    {	
      case Element::e_image:
      {
        $image = new Image($element->GetXObject());
        $image->Export($output_filename); // or ExportAsTiff or ExportAsPng
        // optionally, you can also extract uncompressed/compressed 
        // image data directly using element->GetImageData()
      }
      case Element::e_form:
      {
        $reader->FormBegin();
        ProcessElements($reader);
        $reader->End();
      }
    }
  }
}
```

{% endcode %}
{% endtab %}

{% tab title="Python" %}
{% code lineNumbers="true" %}

```python
doc = PDFDoc(filename)
reader = ElementReader()

itr = doc.GetPageIterator()
while itr.HasNext():
  # Read the page
  reader.Begin(itr.Current())
  ProcessElements(reader)
  reader.End()
  itr.Next()

def ProcessElements(reader):
  # Traverse the page display list
  element = reader.Next()
  while element != None:
    type = element.GetType()
    if type == Element.e_image:
      image = Image(element.GetXObject())
      image.Export(path) # or ExportAsTiff or ExportAsPng
      # optionally, you can also extract uncompressed/compressed 
      # image data directly using element.GetImageData()
    elif type == Element.e_form:
      reader.FormBegin()
      ProcessElements(reader)
      reader.End()
    element = reader.Next()
```

{% endcode %}
{% endtab %}

{% tab title="Ruby" %}
{% code lineNumbers="true" %}

```ruby
doc = PDFDoc.new(filename)
reader = ElementReader.new()

itr = doc.GetPageIterator()
while itr.HasNext() do
  # Read the page
  reader.Begin(itr.Current())
  ProcessElements(reader)
  reader.End()
  itr.Next()
end

def ProcessElements(reader)
  # Traverse the page display list
  element = reader.Next()
  while !element.nil? do
    type = element.GetType()
    case type
    when Element::E_image
      image = Image.new(element.GetXObject())
      image.Export(path) # or ExportAsTiff or ExportAsPng
      # optionally, you can also extract uncompressed/compressed 
      # image data directly using element.GetImageData()
    when Element::E_form:
      reader.FormBegin()
      ProcessElements(reader)
      reader.End()
    end
  end
end
```

{% endcode %}
{% endtab %}

{% tab title="VB" %}
{% code lineNumbers="true" %}

```vb
Dim doc As PDFDoc = New PDFDoc(filename)
Dim reader As ElementReader = New ElementReader

Dim itr As PageIterator = doc.GetPageIterator()
While itr.HasNext()
  ' Read the page
  reader.Begin(itr.Current())
  ProcessElements(reader)
  reader.End()
End While

Sub ProcessElements(ByVal reader As ElementReader)
  ' Traverse the page display list
  Dim element As Element = reader.Next()
  While Not IsNothing(element)
    If element.GetType() = element.Type.e_image Then
      Dim image As PDFTRON.PDF.Image = New PDFTRON.PDF.Image(element.GetXObject())
      image.Export(output_filename)	' or ExporAsPng() or ExporAsTiff() ...
      ' optionally, you can also extract uncompressed/compressed 
      ' image data directly using element.GetImageData()
    ElseIf element.GetType() = element.Type.e_form Then
      reader.FormBegin()
      ProcessElements(reader)
      reader.End()
    End If
    element = reader.Next()
  End While
End Sub
```

{% endcode %}
{% endtab %}
{% endtabs %}

[PDF image extraction](/core/get-started/samples.md#imageextract) Full code sample which illustrates a few approaches to PDF image extraction.

## About reading page content

Page content is represented as a sequence of graphical Elements such as paths, text, images, and forms. The only effect of the ordering of Elements in the display list is the order in which Elements are painted. Elements that occur later in the display list can obscure earlier elements.

A display list can be traversed using an ElementReader object. To start traversing the display list, call `reader.Begin()`. Then, `reader.Next()` will return subsequent Elements until null is returned (marking the end of the display list).

While ElementReader only works with one page at a time, the same ElementReader object may be reused to process multiple pages.

## About Form XObjects, Type3 font glyphs, and tiling patterns

A PDF page display list may contain child display lists of Form XObjects, Type3 font glyphs, and tiling patterns. A form XObject is a self-contained description of any sequence of graphics objects (such as path objects, text objects, and sampled images), defined as a PDF content stream. It may be painted multiple times — either on several pages or at several locations on the same page — and will produce the same results each time (subject only to the graphics state at the time the Form XObject is painted). In order to open a child display list for a Form XObject, call the `reader.FormBegin()` method. To return processing to the parent display list call `reader.End()`. Processing of the Form XObject display (traversing the child display list) is illustrated below.

![](https://3779731113-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fziw3GiL98Xfj63F3He8h%2Fuploads%2Fgit-blob-94e76e0c5230468a3885c42d678169a0134da55b%2Ff038ed3927d062c2f8107f3ed8f583cae53394f7-176x274.gif?alt=media)

Note that, in the above sample code, a child display list is opened when an element with type `Element.ElementType.e_form` is encountered by the `reader.FormBegin()` method. The child display list becomes the current display list until it is closed using `reader.End()`. At this point the processing is returned to the parent display list and the next Element returned will be the Element following the Form XObject. Also note that, because Form XObjects may be nested, a sub-display list could have its own child display lists. The sample above shows traversing these nested Form XObjects recursively.

Similarly, a pattern display list can be opened using `reader.PatternBegin()`, and a Type3 glyph display list can be opened using the `reader.Type3FontBegin()` method.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.apryse.com/core/basic-operations/extraction/image-extract.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.