> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reducto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Extract

> Extract specific fields from documents using the Go SDK

The `Extract.Run()` method pulls specific fields from documents as structured JSON. You define a JSON schema with the fields you need, and Extract returns values matching that schema.

***

## Basic Usage

```go theme={null}
package main

import (
    "context"
    "fmt"
    "io"
    "os"
    
    reducto "github.com/reductoai/reducto-go-sdk"
    "github.com/reductoai/reducto-go-sdk/option"
    "github.com/reductoai/reducto-go-sdk/shared"
)

func main() {
    client := reducto.NewClient(option.WithAPIKey(os.Getenv("REDUCTO_API_KEY")))
    
    // Upload
    file, _ := os.Open("invoice.pdf")
    defer file.Close()
    
    upload, _ := client.Upload(context.Background(), reducto.UploadParams{
        File: reducto.F[io.Reader](file),
    })
    
    // Define schema
    schema := map[string]interface{}{
        "type": "object",
        "properties": map[string]interface{}{
            "invoice_number": map[string]interface{}{
                "type":        "string",
                "description": "The invoice number, typically at the top",
            },
            "total": map[string]interface{}{
                "type":        "number",
                "description": "The total amount due",
            },
        },
    }
    
    // Extract
    result, err := client.Extract.Run(context.Background(), reducto.ExtractRunParams{
        ExtractConfig: reducto.ExtractConfigParam{
            DocumentURL: reducto.F[reducto.ExtractConfigDocumentURLUnionParam](
                shared.UnionString(upload.FileID),
            ),
            Schema: reducto.F[interface{}](schema),
        },
    })
    if err != nil {
        fmt.Printf("Extract error: %v\n", err)
        return
    }
    
    // Access extracted values
    // Result is []interface{} where each element is a map[string]interface{}
    if len(result.Result) > 0 {
        extracted := result.Result[0].(map[string]interface{})
        fmt.Printf("Invoice Number: %v\n", extracted["invoice_number"])
        fmt.Printf("Total: %v\n", extracted["total"])
    }
    
    // Usage information
    fmt.Printf("Pages processed: %d\n", result.Usage.NumPages)
    fmt.Printf("Fields extracted: %d\n", result.Usage.NumFields)
}
```

***

## Method Signatures

### Synchronous Extract

```go theme={null}
func (s *ExtractService) Run(
    ctx context.Context,
    body ExtractRunParams,
    opts ...option.RequestOption,
) (*shared.ExtractResponse, error)
```

### Asynchronous Extract

```go theme={null}
func (s *ExtractService) RunJob(
    ctx context.Context,
    body ExtractRunJobParams,
    opts ...option.RequestOption,
) (*ExtractRunJobResponse, error)
```

The `RunJob` method returns a `JobID` that you can use with `client.Job.Get()` to retrieve results.

***

## Array Extraction

For documents with repeating data (line items, transactions), enable array extraction:

```go theme={null}
schema := map[string]interface{}{
    "type": "object",
    "properties": map[string]interface{}{
        "line_items": map[string]interface{}{
            "type": "array",
            "items": map[string]interface{}{
                "type": "object",
                "properties": map[string]interface{}{
                    "description": map[string]interface{}{"type": "string"},
                    "quantity":    map[string]interface{}{"type": "number"},
                    "price":       map[string]interface{}{"type": "number"},
                },
            },
        },
    },
}

result, err := client.Extract.Run(context.Background(), reducto.ExtractRunParams{
    ExtractConfig: reducto.ExtractConfigParam{
        DocumentURL: reducto.F[reducto.ExtractConfigDocumentURLUnionParam](
            shared.UnionString(upload.FileID),
        ),
        Schema: reducto.F[interface{}](schema),
        ArrayExtract: reducto.F(shared.ArrayExtractConfigParam{
            Enabled: reducto.F(true),
            Mode:    reducto.F(shared.ArrayExtractConfigModeAuto),
        }),
    },
})
```

***

## Citations

Enable citations to get source locations for each extracted value:

```go theme={null}
result, err := client.Extract.Run(context.Background(), reducto.ExtractRunParams{
    ExtractConfig: reducto.ExtractConfigParam{
        DocumentURL: reducto.F[reducto.ExtractConfigDocumentURLUnionParam](
            shared.UnionString(upload.FileID),
        ),
        Schema:           reducto.F[interface{}](schema),
        GenerateCitations: reducto.F(true),
    },
})
```

***

## System Prompt

Add a system prompt to guide extraction:

```go theme={null}
result, err := client.Extract.Run(context.Background(), reducto.ExtractRunParams{
    ExtractConfig: reducto.ExtractConfigParam{
        DocumentURL: reducto.F[reducto.ExtractConfigDocumentURLUnionParam](
            shared.UnionString(upload.FileID),
        ),
        Schema:       reducto.F[interface{}](schema),
        SystemPrompt: reducto.F("Extract financial data from this investment statement."),
    },
})
```

***

## Next Steps

* Learn about [schema design best practices](/extraction/best-practices-extract)
* Explore [array extraction](/configs/extract/array-extraction) for long documents
* Check out [citations](/configs/extract/citations) for source verification