📄 Extract: Word Document Content Extraction

import requests
import json

# Configure API endpoint and authentication
url = "https://powerfile.io/docx/api/extract"
headers = {"Authorization": "YOUR_API_TOKEN"}

# Open and upload the Word document
with open("document.docx", "rb") as f:
    files = {"file": ("document.docx", f, "application/vnd.openxmlformats-officedocument.wordprocessingml.document")}
    data = {
        "mode": "detailed",              # detailed, simple, metadata, content, tables, all
        "file_format": "json",           # json, yaml, toml, csv
    }
    
    response = requests.post(url, headers=headers, files=files, data=data)
    
    if response.status_code == 200:
        result = response.json()
        print("✅ Extraction successful!")
        print(f"Output directory: {result['output_dir']}")
        print(f"Paragraphs extracted: {result['paragraphs_count']}")
        print(f"Tables extracted: {result['tables_count']}")
        print(f"Styles found: {result['styles_count']}")
    else:
        print(f"❌ Error: {response.status_code}")
        print(response.json())

const fs = require('fs');
const FormData = require('form-data');
const axios = require('axios');

// Configure API endpoint and authentication
const url = 'https://powerfile.io/docx/api/extract';
const apiKey = 'YOUR_API_KEY';

// Create form data with file and parameters
const form = new FormData();
form.append('file', fs.createReadStream('document.docx'));
form.append('mode', 'detailed');              // detailed, simple, metadata, content, tables, all
form.append('file_format', 'json');           // json, yaml, toml, csv

// Make the API request
axios.post(url, form, {
  headers: {
    ...form.getHeaders(),
    'Authorization': apiKey
  }
}).then(response => {
  console.log('✅ Extraction successful!');
  console.log('Output directory:', response.data.output_dir);
  console.log('Paragraphs:', response.data.paragraphs_count);
  console.log('Tables:', response.data.tables_count);
  console.log('Styles:', response.data.styles_count);
}).catch(error => {
  console.error('❌ Error:', error.response?.data || error.message);
});

import java.io.File;
import java.io.IOException;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

// Configure API endpoint and authentication
CloseableHttpClient httpClient = HttpClients.createDefault();
HttpPost uploadFile = new HttpPost("https://powerfile.io/docx/api/extract");
uploadFile.setHeader("Authorization", "YOUR_API_TOKEN");

// Build multipart form data
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.addBinaryBody(
    "file", 
    new File("document.docx"),
    ContentType.create("application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
    "document.docx"
);
builder.addTextBody("mode", "detailed");              // detailed, simple, metadata, content, tables, all
builder.addTextBody("file_format", "json");          // json, yaml, toml, csv

HttpEntity multipart = builder.build();
uploadFile.setEntity(multipart);

// Execute request
try (CloseableHttpResponse response = httpClient.execute(uploadFile)) {
    String responseBody = EntityUtils.toString(response.getEntity());
    JsonObject result = JsonParser.parseString(responseBody).getAsJsonObject();
    
    if (response.getStatusLine().getStatusCode() == 200) {
        System.out.println("✅ Extraction successful!");
        System.out.println("Output: " + result.get("output_dir").getAsString());
        System.out.println("Paragraphs: " + result.get("paragraphs_count").getAsInt());
        System.out.println("Tables: " + result.get("tables_count").getAsInt());
    } else {
        System.err.println("❌ Error: " + response.getStatusLine());
    }
} catch (IOException e) {
    e.printStackTrace();
}

using System;
using System.IO;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

// Configure API endpoint and authentication
var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "YOUR_API_TOKEN");

// Create multipart form content
var content = new MultipartFormDataContent();
using (var fileStream = File.OpenRead("document.docx"))
{
    var streamContent = new StreamContent(fileStream);
    streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(
        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
    );
    content.Add(streamContent, "file", "document.docx");
    content.Add(new StringContent("detailed"), "mode");               // detailed, simple, metadata, content, tables, all
    content.Add(new StringContent("json"), "file_format");            // json, yaml, toml, csv

    // Make the API request
    var response = await client.PostAsync("https://powerfile.io/docx/api/extract", content);
    var responseBody = await response.Content.ReadAsStringAsync();
    
    if (response.IsSuccessStatusCode)
    {
        var result = JsonSerializer.Deserialize(responseBody);
        Console.WriteLine("✅ Extraction successful!");
        Console.WriteLine($"Output directory: {result.GetProperty(\"output_dir\").GetString()}");
        Console.WriteLine($"Paragraphs: {result.GetProperty(\"paragraphs_count\").GetInt32()}");
        Console.WriteLine($"Tables: {result.GetProperty(\"tables_count\").GetInt32()}");
        Console.WriteLine($"Styles: {result.GetProperty(\"styles_count\").GetInt32()}");
    }
    else
    {
        Console.WriteLine($"❌ Error: {response.StatusCode}");
        Console.WriteLine(responseBody);
    }
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	// Open the Word document
	file, err := os.Open("document.docx")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	// Create multipart form data
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "document.docx")
	io.Copy(part, file)
	
	// Add form fields
	writer.WriteField("mode", "detailed")              // detailed, simple, metadata, content, tables, all
	writer.WriteField("file_format", "json")          // json, yaml, toml, csv
	writer.Close()

	// Create and configure request
	req, _ := http.NewRequest("POST", "https://powerfile.io/docx/api/extract", body)
	req.Header.Set("Authorization", "YOUR_API_TOKEN")
	req.Header.Set("Content-Type", writer.FormDataContentType())

	// Execute request
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	// Parse response
	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	
	if resp.StatusCode == 200 {
		fmt.Println("✅ Extraction successful!")
		fmt.Println("Output:", result["output_dir"])
		fmt.Println("Paragraphs:", result["paragraphs_count"])
		fmt.Println("Tables:", result["tables_count"])
		fmt.Println("Styles:", result["styles_count"])
	} else {
		fmt.Printf("❌ Error: %d\n", resp.StatusCode)
	}
}