Extract File

import requests
from pulse import Pulse

API_KEY = "YOUR_API_KEY"
client = Pulse(api_key=API_KEY)

response = client.extract(
    file_url="https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf"
)

if hasattr(response, "is_url") and response.is_url:
    full_result = requests.get(
        response.url,
        headers={"x-api-key": API_KEY},
    ).json()
    print(full_result["markdown"])
else:
    print(response.markdown)

import { PulseClient } from 'pulse-ts-sdk';

const API_KEY = "YOUR_API_KEY";
const client = new PulseClient({ apiKey: API_KEY });

const response = await client.extract({
    fileUrl: "https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf"
});

if ((response as any).is_url) {
    const fullResult = await fetch((response as any).url, {
        headers: { "x-api-key": API_KEY },
    }).then(r => r.json());
    console.log(fullResult.markdown);
} else {
    console.log(response.markdown);
}

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@large_document.pdf"

# Response: {"is_url": true, "url": "https://api.runpulse.com/results/abc123-..."}

# Fetch the complete result
curl -H "x-api-key: YOUR_API_KEY" \
  "https://api.runpulse.com/results/abc123-..."

from pulse import Pulse
from pulse.types import (
    ExtractRequestFigureProcessing,
    ExtractRequestExtensions,
    ExtractRequestExtensionsAltOutputs,
)

client = Pulse(api_key="YOUR_API_KEY")

# Extract from URL with figure processing and HTML output
response = client.extract(
    file_url="https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    figure_processing=ExtractRequestFigureProcessing(
        description=True,
    ),
    extensions=ExtractRequestExtensions(
        alt_outputs=ExtractRequestExtensionsAltOutputs(
            return_html=True,
        ),
    ),
)

print(f"Markdown: {response.markdown}")
print(f"HTML: {response.extensions.alt_outputs.html}")
print(f"Extraction ID: {response.extraction_id}")

import { PulseClient } from 'pulse-ts-sdk';

const client = new PulseClient({ apiKey: "YOUR_API_KEY" });

const response = await client.extract({
    fileUrl: "https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    figureProcessing: { description: true },
    extensions: { altOutputs: { returnHtml: true } }
});

console.log(`Markdown: ${response.markdown}`);
console.log(`HTML: ${response.extensions?.altOutputs?.html}`);
console.log(`Extraction ID: ${response.extraction_id}`);

# Extract from URL with figure processing
curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file_url": "https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    "figure_processing": {"description": true},
    "extensions": {"alt_outputs": {"return_html": true}}
  }'

from pulse.types import ExtractRequestFigureProcessing

# Upload and extract a local file
with open("document.pdf", "rb") as f:
    response = client.extract(
        file=f,
    figure_processing=ExtractRequestFigureProcessing(
        description=True,
    ),
    )

import * as fs from 'fs';

const fileBuffer = fs.readFileSync("document.pdf");
const blob = new Blob([fileBuffer], { type: 'application/pdf' });

const response = await client.extract({
    file: blob,
});

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@document.pdf"

# Step 1: Extract the document
response = client.extract(
    file_url="https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf"
)

extraction_id = response.extraction_id

# Step 2: Apply schema separately
schema_result = client.schema(
    extraction_id=extraction_id,
    schema_config={
        "input_schema": {
            "type": "object",
            "properties": {
                "total": {"type": "number"},
                "vendor": {"type": "string"}
            }
        },
        "schema_prompt": "Extract invoice total and vendor"
    }
)

print(schema_result.schema_output)

// Step 1: Extract the document
const response = await client.extract({
    fileUrl: "https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf"
});

const extractionId = response.extraction_id;

// Step 2: Apply schema separately
const schemaResult = await client.schema({
    extraction_id: extractionId,
    schema_config: {
        input_schema: {
            type: "object",
            properties: {
                total: { type: "number" },
                vendor: { type: "string" }
            }
        },
        schema_prompt: "Extract invoice total and vendor"
    }
});

console.log(schemaResult.schema_output);

# Step 1: Extract the document
curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@invoice.pdf"

# Response includes extraction_id: "abc123-..."

# Step 2: Apply schema
curl -X POST https://api.runpulse.com/schema \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "extraction_id": "abc123-...",
    "schema_config": {
      "input_schema": {"type": "object", "properties": {"total": {"type": "number"}, "vendor": {"type": "string"}}},
      "schema_prompt": "Extract invoice total and vendor"
    }
  }'

from pulse.types import ExtractRequestExtensions

response = client.extract(
    file_url="https://example.com/report.pdf",
    extensions=ExtractRequestExtensions(
        document_metadata=True,
    ),
)

metadata = response.extensions.document_metadata
print(metadata.properties.title)
print(metadata.structure.page_count)

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@report.pdf" \
  -F 'extensions={"document_metadata":true};type=application/json'

from pulse.types import (
    ExtractRequestExtensions,
    ExtractRequestExtensionsChunking,
)

response = client.extract(
    file_url="https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    pages="1-5,10",  # 1-indexed
    extensions=ExtractRequestExtensions(
        chunking=ExtractRequestExtensionsChunking(
            chunk_types=["semantic", "page"],
            chunk_size=1000,
        ),
    ),
)

# Chunk data is in extensions.chunking
print(response.extensions.chunking.semantic)
print(response.extensions.chunking.page)

const response = await client.extract({
    fileUrl: "https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    pages: "1-5,10",  // 1-indexed
    extensions: {
        chunking: {
            chunkTypes: ["semantic", "page"],
            chunkSize: 1000
        }
    }
});

// Chunk data is in extensions.chunking
console.log(response.extensions?.chunking?.semantic);
console.log(response.extensions?.chunking?.page);

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@document.pdf" \
  -F "pages=1-5,10" \
  -F 'extensions={"chunking": {"chunk_types": ["semantic", "page"], "chunk_size": 1000}}'

from pulse.types import ExtractRequestExtensions

response = client.extract(
    file_url="https://example.com/research-paper.pdf",
    extensions=ExtractRequestExtensions(
        footnote_references=True,
    ),
)

# Footnote links are in extensions.footnote_references
for ref in response.extensions.footnote_references:
    print(f"Marker: {ref.symbol}")
    print(f"  Footnote: {ref.footnote_text_id}")
    print(f"  Referenced by: {ref.reference_text_ids}")

const response = await client.extract({
    fileUrl: "https://example.com/research-paper.pdf",
    extensions: {
        footnoteReferences: true
    }
});

// Footnote links are in extensions.footnoteReferences
for (const ref of response.extensions?.footnoteReferences ?? []) {
    console.log(`Marker: ${ref.symbol}`);
    console.log(`  Footnote: ${ref.footnoteTextId}`);
    console.log(`  Referenced by: ${ref.referenceTextIds}`);
}

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@research-paper.pdf" \
  -F 'extensions={"footnote_references": true}'

from pulse import Pulse
from pulse.types import ExtractRequestSpreadsheet

client = Pulse(api_key="YOUR_API_KEY")

# Extract from Excel with hidden content included
response = client.extract(
    file=open("financials.xlsx", "rb"),
    spreadsheet=ExtractRequestSpreadsheet(
        include_hidden_rows=True,
        include_hidden_cols=True,
        include_hidden_sheets=False,
    ),
)

print(response.markdown)

import { PulseClient } from 'pulse-ts-sdk';

const client = new PulseClient({
    headers: { 'x-api-key': 'YOUR_API_KEY' }
});

const response = await client.extract({
    file: fs.createReadStream("financials.xlsx"),
    spreadsheet: {
        includeHiddenRows: true,
        includeHiddenCols: true,
        includeHiddenSheets: false
    }
});

console.log(response.markdown);

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@financials.xlsx" \
  -F 'spreadsheet={"include_hidden_rows": true, "include_hidden_cols": true, "include_hidden_sheets": false, "cell_data_mode": "inline"}'

import re
from pulse import Pulse
from pulse.types import ExtractRequestFigureProcessing

client = Pulse(api_key="YOUR_API_KEY")

# 1) Extract the workbook with show_images enabled.
response = client.extract(
    file=open("financials.xlsx", "rb"),
    figure_processing=ExtractRequestFigureProcessing(
        show_images=True,
        description=False,
    ),
)

# 2) Walk the typed Images array.
for img in response.bounding_boxes.images or []:
    print(f"{img.id}: {img.visual_type} '{img.chart_title}' @ {img.excel_range}")
    print(f"    url: {img.image_url}")

# 3) Fetch the bytes for one chart.
img = response.bounding_boxes.images[0]
m = re.search(r"/results/([^/]+)/images/([^/?#]+)", img.image_url)
job_id, filename = m.group(1), m.group(2)

chunks = list(client.results.get_image(job_id=job_id, filename=filename))
with open("chart.png", "wb") as f:
    f.write(b"".join(chunks))

import { PulseClient } from "pulse-ts-sdk";
import * as fs from "node:fs";

const client = new PulseClient({ apiKey: "YOUR_API_KEY" });

// 1) Extract the workbook with show_images enabled.
const response = await client.extract({
    file: fs.createReadStream("financials.xlsx"),
    figureProcessing: { showImages: true, description: false },
});

// 2) Walk the typed Images array.
for (const img of response.boundingBoxes?.Images ?? []) {
    console.log(
        `${img.id}: ${img.visualType} '${img.chartTitle}' @ ${img.excelRange}`,
    );
    console.log(`    url: ${img.imageUrl}`);
}

// 3) Fetch the bytes for one chart.
const url = response.boundingBoxes?.Images?.[0]?.imageUrl;
const m = url?.match(/\/results\/([^/]+)\/images\/([^/?#]+)/);
const [, jobId, filename] = m!;
const image = await client.results.getImage({ jobId, filename });
// Persist `image` per your runtime (e.g. `await image.bytes()`).

# Step 1: extract and capture an image_url from the response.
curl -sS -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@financials.xlsx" \
  -F 'figure_processing={"show_images": true}' \
  | jq -r '.bounding_boxes.Images[0].image_url'

# Step 2: fetch the PNG bytes.
curl -sS -X GET "https://api.runpulse.com/results/$JOB_ID/images/excel_image_1_1.png" \
  -H "x-api-key: YOUR_API_KEY" \
  -o chart.png

response = client.extract(
    file_url="https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    storage={"enabled": False}
)

const response = await client.extract({
    fileUrl: "https://platform.runpulse.com/api/examples/637e5678-30b1-45fa-acc4-877f2d636419/pdf",
    storage: { enabled: false }
});

curl -X POST https://api.runpulse.com/extract \
  -H "x-api-key: YOUR_API_KEY" \
  -F "file=@document.pdf" \
  -F 'storage={"enabled": false}'