Split

The Split.Run() method divides documents into sections based on descriptions you provide. You define what sections to look for, and Split identifies which pages belong to each section.

The Go SDK (v0.1.0-alpha.1) has a type definition mismatch for Split responses. The splits array is returned in the API response but not typed in the SDK. Use the raw JSON to access split results reliably.

Basic Usage

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "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")))
    
    // Split the document - split_description is required
    result, err := client.Split.Run(context.Background(), reducto.SplitRunParams{
        DocumentURL: reducto.F[reducto.SplitRunParamsDocumentURLUnion](
            shared.UnionString("https://example.com/document.pdf"),
        ),
        SplitDescription: reducto.F([]shared.SplitCategoryParam{
            {
                Name:        reducto.F("Summary"),
                Description: reducto.F("Executive summary or overview section"),
            },
            {
                Name:        reducto.F("Financial Data"),
                Description: reducto.F("Tables with financial figures"),
            },
        }),
    })
    if err != nil {
        fmt.Printf("Split error: %v\n", err)
        return
    }
    
    // Parse raw JSON to access splits (SDK type limitation workaround)
    var splitResult struct {
        Splits []struct {
            Name       string  `json:"name"`
            Pages      []int64 `json:"pages"`
            Conf       string  `json:"conf"`
            Partitions []interface{} `json:"partitions"`
        } `json:"splits"`
    }
    
    rawJSON := result.JSON.RawJSON()
    // Extract the result portion
    var fullResult map[string]json.RawMessage
    json.Unmarshal([]byte(rawJSON), &fullResult)
    json.Unmarshal(fullResult["result"], &splitResult)
    
    // Access splits
    for _, split := range splitResult.Splits {
        fmt.Printf("Section: %s\n", split.Name)
        fmt.Printf("Pages: %v\n", split.Pages)
        fmt.Printf("Confidence: %s\n", split.Conf)
    }
}

Method Signatures

Synchronous Split

func (s *SplitService) Run(
    ctx context.Context,
    body SplitRunParams,
    opts ...option.RequestOption,
) (*shared.SplitResponse, error)

Asynchronous Split

func (s *SplitService) RunJob(
    ctx context.Context,
    body SplitRunJobParams,
    opts ...option.RequestOption,
) (*SplitRunJobResponse, error)

Parameters

SplitRunParams

Field	Type	Required	Description
`DocumentURL`	`SplitRunParamsDocumentURLUnion`	Yes	File URL, `reducto://` file ID, or `jobid://` reference
`SplitDescription`	`[]shared.SplitCategoryParam`	Yes	List of sections to identify
`SplitRules`	`string`	No	Natural language prompt for classification rules
`AdvancedOptions`	`shared.AdvancedProcessingOptionsParam`	No	Advanced processing options
`Options`	`shared.BaseProcessingOptionsParam`	No	Base processing options

SplitCategoryParam

Each split category requires:

shared.SplitCategoryParam{
    Name:         reducto.F("Section Name"),
    Description:  reducto.F("Description of what this section contains"),
    PartitionKey: reducto.F("optional_partition_key"),  // Optional
}

Configuration Examples

With Partition Key

Use PartitionKey when a section type repeats multiple times:

result, err := client.Split.Run(context.Background(), reducto.SplitRunParams{
    DocumentURL: reducto.F[reducto.SplitRunParamsDocumentURLUnion](
        shared.UnionString(upload.FileID),
    ),
    SplitDescription: reducto.F([]shared.SplitCategoryParam{
        {
            Name:         reducto.F("Invoice"),
            Description:  reducto.F("Individual invoice with line items"),
            PartitionKey: reducto.F("invoice_number"),
        },
    }),
})

With Split Rules

result, err := client.Split.Run(context.Background(), reducto.SplitRunParams{
    DocumentURL: reducto.F[reducto.SplitRunParamsDocumentURLUnion](
        shared.UnionString(upload.FileID),
    ),
    SplitDescription: reducto.F([]shared.SplitCategoryParam{
        {Name: reducto.F("Summary"), Description: reducto.F("Executive summary")},
        {Name: reducto.F("Details"), Description: reducto.F("Detailed content")},
    }),
    SplitRules: reducto.F("Pages can belong to multiple sections if they contain content from both."),
})

Response Structure

Due to SDK type limitations, access the response via raw JSON:

// API Response structure (access via raw JSON)
type SplitResult struct {
    Splits []struct {
        Name       string        `json:"name"`       // Section name you defined
        Pages      []int64       `json:"pages"`      // Page numbers (1-indexed)
        Conf       string        `json:"conf"`       // "high" or "low"
        Partitions []interface{} `json:"partitions"` // Sub-sections (if partition_key used)
    } `json:"splits"`
}

Error Handling

result, err := client.Split.Run(context.Background(), params)
if err != nil {
    fmt.Printf("Split failed: %v\n", err)
    return
}

Next Steps

Learn about split configuration options
Check out parsing split sections for further processing

Get Started

Core Methods

Utilities

Basic Usage

Method Signatures

Synchronous Split

Asynchronous Split

Parameters

SplitRunParams

SplitCategoryParam

Configuration Examples

With Partition Key

With Split Rules

Response Structure

Error Handling

Next Steps

​Basic Usage

​Method Signatures

​Synchronous Split

​Asynchronous Split

​Parameters

​SplitRunParams

​SplitCategoryParam

​Configuration Examples

​With Partition Key

​With Split Rules

​Response Structure

​Error Handling

​Next Steps

Basic Usage

Method Signatures

Synchronous Split

Asynchronous Split

Parameters

SplitRunParams

SplitCategoryParam

Configuration Examples

With Partition Key

With Split Rules

Response Structure

Error Handling

Next Steps