xParse for RAG and Agents

Author: intsig-textin
Version: 1.2.1
Type: tool

Description

Parse complex documents into Markdown, structured elements, tables, and images for RAG pipelines and agent workflows.

xParse is a structured document parsing tool built for RAG pipelines and agent workflows. It parses PDFs, Word, Excel, PowerPoint, images, and other files into model-ready outputs, including Markdown text, structured elements, tables, and images.

Unlike simple document-to-text conversion tools, xParse is designed for workflows that need richer document structure and layout-aware understanding. It helps turn complex files into content that can be used for knowledge ingestion, retrieval, agent reasoning, information extraction, and downstream automation.

Use xParse when your workflow needs more than plain text output — for example, when you need document sections, titles, tables, image blocks, page-level metadata, or structured content elements that can be passed into later nodes in Dify. xParse returns Markdown in the field, structured blocks in , and image resources in , which makes it more suitable for multi-step workflows than a simple Markdown-only parser.

Supports both Free API and Paid API — install and use immediately without any credentials.

Best For

RAG document preprocessing
Knowledge base ingestion
Agent document reading and reasoning
Structured information extraction
Table and layout-aware parsing
Multi-step workflow automation
Image-aware document understanding

Quick Start

1. Free API (Default, No Credentials Required)

Simply install the plugin in Dify and start using it — no credentials needed. Leave the and fields empty during provider configuration.

The free API supports PDF and images (JPG/PNG/BMP/TIFF/WebP), with a daily limit of 1,000 pages.

2. Paid API (Optional)

For higher usage or more formats (Word/Excel/PPT/HTML/OFD and 20+ other formats), get credentials from Textin Console and fill in and in the provider configuration.

Provider Credentials

Parameter	Type	Required	Description
	secret-input	No	Textin application ID. Only required for paid API. Leave empty to use the free API.
	secret-input	No	Textin secret code. Only required for paid API. Leave empty to use the free API.

Get credentials for paid API: Please login to Textin and go to Workspace → Account Settings → Developer Information to view your and .

Parse Input Parameters

The xParse Parse tool provides parameters to customize document processing and control the level of detail in returned data.

The only required parameter is – the file you wish to process.

Main Parameters

Type	Required	Default	Description
file	Yes	-	The file to be parsed (supports PDF, WORD, EXCEL, PPT, images, etc.)
string	No	-	Password for encrypted PDF files
string	No	-	Specify page ranges to parse. Format: for pages 1-2, for multiple ranges

Capabilities Parameters

Control what additional information is included in the response:

Type	Required	Description
boolean	No	Whether to return element hierarchy and relationships (parent_id, children_ids, ref_element_id) for building document structure graph
boolean	No	Whether to return fine-grained inline objects (formulas, handwriting, checkboxes, images within text)
boolean	No	Whether to return character-level details (coordinates, confidence, candidate characters)
boolean	No	Whether to return image data (image_url, mime_type, base64). When enabled, base64 images are automatically uploaded to Dify
boolean	No	Whether to return detailed table structure in JSON format (rows, cols, cells with coordinates and content)
boolean	No	Whether to return page metadata list (page dimensions, page_image_url, element_ids per page)
boolean	No	Whether to return hierarchical title tree (table of contents)
select	No	Format of tables in markdown. Options: (simple), (supports complex tables with merged cells)

API Limits

Limit	Free API	Paid API
Supported formats	PDF, images (JPG/PNG/BMP/TIFF/WebP)	20+ formats (PDF, images, Word, Excel, PPT, HTML, OFD, etc.)
Daily usage	1,000 pages	Per plan
File size	10MB	500MB
PDF pages	—	1,000 pages
XLS/XLSX/CSV	—	≤ 2,000 rows × 100 cols per sheet
TXT	—	≤ 100KB
Image dimensions	20–20,000 px	20–20,000 px

Notes

For more details on capabilities and parameters, refer to the Parse Config Documentation.
Enable only the capabilities you need to optimize performance and response size.
Default values are optimized for common use cases.

API Response Structure

Top-Level Output Variables

The tool returns structured data with the following output variables:

Variable	Type	Description
	string	The full document content in Markdown format (from API's field)
	array of object	List of structured elements extracted from the document
	array of object	List of page metadata (only returned if capability is enabled)
	array of object	Hierarchical title tree / table of contents (only returned if capability is enabled)
	array of object	List of images uploaded to Dify (only returned if is enabled and images are present)

Field Details

text

Type: string
Description:
The entire document content formatted in Markdown. This comes directly from the API's field and includes proper formatting for headings, paragraphs, tables, images, etc.

elements

Type: array of objects
Description:
List of structured elements extracted from the document. Each element represents a semantic unit (title, paragraph, table, image, etc.) with metadata.

Each element object contains:

Field	Type	Description
	string	Unique identifier for the element
	string	Element type: , , , , , , , , , , , , ,
	string	Optional sub-type for further classification (e.g., for Image: , , , )
	string	Text content of the element
	integer	Page number where the element appears (starting from 1)
	array	8-element array representing normalized quadrilateral coordinates [x1,y1,x2,y2,x3,y3,x4,y4] in range [0,1]
	object	Element metadata (see below)
	array	Inline objects within the element (only if is enabled)
	object	Table structure details (only for Table elements if is enabled)
	array	Character-level details (only if is enabled)
	object	Image data (only for Image elements if is enabled)

Element metadata

The field provides contextual information:

Field	Type	Description
	string	Parent element ID (if is enabled)
	array	Child element IDs (if is enabled)
	integer	Nesting depth for elements of the same type (e.g., 0 for H1, 1 for H2)
	string	Referenced element ID, e.g., linking image to its caption (if is enabled)
	boolean	Whether this element continues from a previous page
	string	Element ID that this continues from (if is true)
	boolean	Whether the element contains inline objects
	array	Types of inline objects present (e.g., )
	integer	Image width in pixels (for Image elements)
	integer	Image height in pixels (for Image elements)
	object	Data source information including protocol, path, and URLs

pages

Type: array of objects
Description:
List of page metadata (only returned if capability is enabled). Each page object contains:

Field	Type	Description
	integer	Page number (starting from 1)
	number	Page width in pixels
	number	Page height in pixels
	string	URL of the rendered page image
	array	List of element IDs on this page in reading order
	integer	DPI used for rendering
	number	Page rotation angle (0 is normal reading orientation, clockwise)
	string	Processing status of the page

title_tree

Type: array of objects
Description:
Hierarchical document outline (only returned if capability is enabled). Each node contains:

Field	Type	Description
	string	Element ID of the corresponding Title element
	string	Title text
	integer	Title level (1 is highest, i.e., H1)
	integer	Page number where the title appears
	array	Nested child title nodes

images

Type: array of objects
Description:
List of images uploaded to Dify's file system (only returned if is enabled and images with base64 data are present). Each image object contains:

Field	Type	Description
	string	Dify file ID
	string	Image file name
	string	MIME type of the image
	string	URL for image preview
	integer	Image file size in bytes
	string	Always

Example Response

JSON Structure

Typical Workflow Use Cases

Knowledge ingestion for RAG — Upload a PDF or Office file → parse into Markdown and structured elements → chunk and index into your knowledge base.
Agent document understanding — Let your agent read contracts, reports, manuals, and forms through structured outputs instead of raw files.
Structured information extraction — Parse documents first, then pass clean text blocks, tables, and metadata into downstream extraction, summarization, or decision nodes.
Layout-aware processing — Use titles, page coordinates, tables, and image blocks to support more accurate retrieval, routing, and document automation.

Usage

Install this plugin in Dify
Configure Provider — leave credentials empty for free API, or fill in for paid API
Use the Parse tool in Workflow or Agent applications
Upload a file and configure parsing parameters
Use the returned , , and in downstream nodes

API Reference

Notes

The field is suitable for direct display or LLM input.
The field is useful for structured processing, chunking, highlighting, and further analysis.
The field provides image resources for preview or multimodal workflows.
The and fields offer document structure insights.
When is enabled, images with base64 data are automatically uploaded to Dify's file system, and the array contains the uploaded file information.
Coordinates are normalized to [0, 1] range relative to page dimensions. To convert to pixels, multiply by page width/height.

Tags: RAG, Agent, Document Parsing, Structured Extraction, Knowledge Ingestion, PDF Parsing, Markdown, Tables, Layout Parsing