Native App on Snowflake Marketplace

Deploy Upstage AI capabilities directly within your Snowflake environment as a serverless native application. The Native App runs entirely within your Snowflake account, ensuring data privacy and compliance while leveraging Snowflake's compute resources for document processing and AI operations.

Overview

Native App for Snowflake provides powerful AI capabilities directly within your Snowflake environment.

All processing happens securely within your Snowflake account using Snowflake's native compute pools and container services. Your data never leaves your environment.

Funcional Differences from Upstage Console

Payload Size: Supports up to 50MB per request, same as Upstage Console.
Page Limit: Up to 100 pages per request (synchronous processing).
Response Size: Large responses can hit Snowflake's per-row size limit. If you encounter Row is too large to be serialized for external function, see the Handling the 16MB Response Limit section below.
File Format Support: For Document Parsing capabilities, HWP file format is not supported.
Processing Mode: Currently supports synchronous processing only.
Auto Resume & Restart: Compute pools suspend when idle to avoid costs, but expect a short delay while AI models reload during auto resume.

Required Prerequisites

Before installing the Native App, ensure you have the following privileges:

CREATE COMPUTE POOL: Required to run the application service via Snowflake Container Services
CREATE WAREHOUSE: Required for executing queries within Snowflake
Database and Schema Access: Permissions to grant access to your databases, schemas, and stages

These privileges are typically held by account administrators. Contact your Snowflake admin if you lack these permissions.

Common Installation & Setup

Install from Snowflake Marketplace

Navigate to Snowflake Marketplace and search for Upstage.
Click Product list item on the Upstage listing to start installation.
Review the listing details & terms of service, and click Try Now to confirm. The application will be installed with a default name if not specified. ((e.g. Document Parse))

Initialize the Application

After installation, initialize the application to deploy the compute services. This process provisions GPU resources for document processing.

-- Initialize and deploy the application service
-- Note: Assuming application is installed as UPSTAGE_APP
CALL UPSTAGE_APP.app_public.start_app();

Important: GPU resource provisioning takes 5-10 minutes. The service must be ready before processing documents.

Check service status:

-- Check if service is ready
CALL UPSTAGE_APP.app_public.service_status();

Wait until the status shows READY for all containers before proceeding.

Grant Data Access Permissions

To allow the application to read files from your Snowflake stages, grant the necessary permissions. All three grants are required:

-- 1. Grant database access
GRANT USAGE ON DATABASE <YOUR_DATABASE> TO APPLICATION UPSTAGE_APP;

-- 2. Grant schema access
GRANT USAGE ON SCHEMA <YOUR_DATABASE>.<YOUR_SCHEMA> TO APPLICATION UPSTAGE_APP;

-- 3. Grant stage read access
GRANT READ ON STAGE <YOUR_DATABASE>.<YOUR_SCHEMA>.<YOUR_STAGE> TO APPLICATION UPSTAGE_APP;

That's it! You can now use the Native App to use our capabilities.

Available Capabilities

Document Parse

Usage

Method 1: Process Files from Snowflake Stage (Recommended)

After granting access permissions (see Installation step 3), process files directly from your Snowflake stages.

Basic Document Parsing:

-- Process a single document with default settings
CALL DOCUMENT_PARSE.app_public.document_parse(
    '@my_database.public.my_documents/invoice.pdf'
);

-- Process document in subdirectory
CALL DOCUMENT_PARSE.app_public.document_parse(
    '@my_database.public.my_documents/invoices/2025/invoice_001.pdf'
);

Advanced Usage with Custom Options:

You can customize parsing behavior using a JSON options parameter:

-- Basic syntax with options
CALL DOCUMENT_PARSE.app_public.document_parse(
    '@<DATABASE>.<SCHEMA>.<STAGE>/<FILE_PATH>',
    '{"option_name": value, "another_option": value}'
);

Available Options: For detailed information about these options, please refer to the Document Parse API reference.

Option	Type	Default	Description
`chart_recognition`	boolean	`true`	Convert charts to structured tables
`merge_multipage_tables`	boolean	`false`	Merge tables spanning multiple pages
`ocr`	string	`"auto"`	OCR mode: `"auto"` (images only) or `"force"` (always)
`output_formats`	array	`["html"]`	Output formats: `"text"`, `"html"`, `"markdown"`
`coordinates`	boolean	`true`	Include bounding box coordinates
`base64_encoding`	array	`[]`	Layout categories to encode as base64 (e.g., `["table"]`)

Practical Examples:

-- Example 1: Disable chart recognition for no-chart document
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/report.pdf',
    '{"chart_recognition": false}'
);

-- Example 2: Merge multi-page tables and force OCR for scanned documents
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/scanned_contract.pdf',
    '{"merge_multipage_tables": true, "ocr": "force"}'
);

-- Example 3: Generate multiple output formats
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/research_paper.pdf',
    '{"output_formats": ["html", "markdown", "text"]}'
);

-- Example 4: Extract table images as base64 for further processing
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/data_sheet.pdf',
    '{"base64_encoding": ["table"], "coordinates": true}'
);

-- Example 5: Simple text extraction without coordinates
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/memo.pdf',
    '{"output_formats": ["text"], "coordinates": false}'
);

-- Example 6: Complex document with all features
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/annual_report.pdf',
    '{"chart_recognition": true, "merge_multipage_tables": true, "ocr": "auto", "output_formats": ["html", "markdown"]}'
);

Method 2: Process with Base64-Encoded Data

If you prefer to handle file reading yourself or already have base64-encoded data:

-- Basic usage
CALL UPSTAGE_APP.app_public.document_parse_base64(
    'base64_encoded_string_here'
);

-- With custom options
CALL UPSTAGE_APP.app_public.document_parse_base64(
    'base64_encoded_string_here',
    '{"chart_recognition": false, "output_formats": ["text"]}'
);

When to use base64 method:

Custom file reading logic from external sources
Processing data from external APIs
Pre-processing files before sending to the app
Already have base64-encoded data from another system

Response Format

The procedure returns a JSON object with the complete parsed document structure:

{
  "api": "2.0",
  "content": {
    "html": "<figure id='0'><img style='font-size:14px' alt='...' /></figure>",
    "markdown": "# Document Title\n\n...",
    "text": "Document Title..."
  },
  "elements": [
    {
      "category": "figure",
      "content": {
        "html": "...",
        "markdown": "",
        "text": ""
      },
      "coordinates": [
        {"x": 0.1773, "y": 0.1544},
        {"x": 0.7738, "y": 0.1544},
        {"x": 0.7738, "y": 0.9171},
        {"x": 0.1773, "y": 0.9171}
      ],
      "id": 0,
      "page": 1
    }
  ],
  "model": "document-parse",
  "ocr": true,
  "usage": {
    "pages": 1
  }
}

Performance Tips

For scanned documents: Use "ocr": "force" for best results
For digital PDFs: Use "ocr": "auto" (default) to skip unnecessary OCR
For large documents: Consider processing in batches if possible
For table extraction: Enable "merge_multipage_tables": true for tables spanning pages
For minimal response: Set "coordinates": false and "output_formats": ["text"]
For high-quality scans: Use 300 DPI or higher for best OCR accuracy

Handling the 16MB Response Limit

Snowflake enforces a hard limit of 16MB per row when returning serialized data. Because Document Parse returns the entire parsed result as a single row, large or image-heavy documents can exceed this limit and trigger the following error:

Row is too large to be serialized for external function

If you run into this error, try one or more of the following:

Split multi-page documents: Break the document into smaller page ranges (e.g., 10–20 pages per request) and process them separately. Merge the results using a Snowflake stored procedure or in your application code.
Disable base64_encoding: Base64-encoded image payloads (e.g., ["table"], ["figure"]) account for a large portion of the response size. Set base64_encoding to [] (default) when you don't need the encoded images.
Reduce output formats: Request only the formats you actually need — e.g., use "output_formats": ["text"] or ["markdown"] instead of including all three (text, html, markdown).
Drop coordinates: Set "coordinates": false if bounding box information isn't required for your use case.

-- Example: minimize response size for a large document
CALL UPSTAGE_APP.app_public.document_parse(
    '@my_database.public.my_stage/large_report.pdf',
    '{"output_formats": ["markdown"], "coordinates": false, "base64_encoding": []}'
);

API Reference

For detailed API specifications and advanced usage:

Cost Management Tips

Warehouse Auto-Suspend: Configure warehouses to auto-suspend when idle to minimize costs
Compute Pool Management: Monitor compute pool usage and auto-suspend settings
Query Optimization: Use filters and limits to minimize unnecessary document processing
Storage Optimization: Archive or remove processed documents when no longer needed
Output Format Selection: Request only needed formats to reduce response size and processing time

Support

Getting Help

For questions about the Snowflake Native App or technical assistance:

Technical Support

Visit Upstage Support for technical issues
Review the Troubleshooting section above for common issues
Check service status and error messages for diagnostic information

Sales and Pricing

Contact our sales team for enterprise deployment options
Email contact@upstage.ai for volume discounts and custom solutions