Extração de Dados - FlexExtractor

# Primeiro, obtenha o token
TOKEN=$(curl -X POST "https://hml.flexextractor.com.br/api/v2/Security/GetToken" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=seu_username" \
  -d "password=sua_senha" | jq -r '.access_token')

# Depois, extraia dados do documento
curl -X POST "https://hml.flexextractor.com.br/api/v2/FlexOCR/Extract/Json" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "typealias": "RG",
    "imageBase64": "JVBERi0xLjMNCiXi48/TDQoyIDAgb2J..."
  }'

const axios = require('axios');
const fs = require('fs');

// Função auxiliar para converter imagem para Base64
function imageToBase64(filePath) {
  const imageBuffer = fs.readFileSync(filePath);
  return imageBuffer.toString('base64');
}

// Função principal de extração
async function extractDocumentData(accessToken, imagePath, docType = null) {
  const imageBase64 = imageToBase64(imagePath);

  const requestBody = {
    imageBase64: imageBase64
  };

  // Adiciona tipo de documento se informado
  if (docType) {
    requestBody.typealias = docType;
  }

  try {
    const response = await axios.post(
      'https://hml.flexextractor.com.br/api/v2/FlexOCR/Extract/Json',
      requestBody,
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        }
      }
    );

    const { ocrResult, isSuccesful, statusCode } = response.data;

    if (isSuccesful) {
      console.log('✓ Extração realizada com sucesso!');
      console.log(`Tipo reconhecido: ${ocrResult.typeRecognized}`);
      console.log(`Campos extraídos: ${ocrResult.fields.length}`);
      console.log('\nDados extraídos:');

      ocrResult.fields.forEach(field => {
        console.log(`  ${field.name}: ${field.value} (confiança: ${field.confidence}%)`);
      });

      return ocrResult;
    } else {
      console.error('✗ Erro na extração:', response.data.error);
      return null;
    }
  } catch (error) {
    console.error('✗ Erro na requisição:', error.response?.data || error.message);
    throw error;
  }
}

// Uso
const token = 'seu_access_token_aqui';
extractDocumentData(token, './documento_rg.jpg', 'RG');

import requests
import base64
import json

def image_to_base64(file_path: str) -> str:
    """Converte imagem para Base64"""
    with open(file_path, 'rb') as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

def extract_document_data(access_token: str, image_path: str, doc_type: str = None):
    """
    Extrai dados de documento usando FlexExtractor

    Args:
        access_token: Token de autenticação
        image_path: Caminho do arquivo de imagem
        doc_type: Tipo do documento (RG, CNH, etc) - opcional

    Returns:
        dict: Dados extraídos do documento
    """
    url = "https://hml.flexextractor.com.br/api/v2/FlexOCR/Extract/Json"

    # Converte imagem para Base64
    image_base64 = image_to_base64(image_path)

    # Monta corpo da requisição
    payload = {
        "imageBase64": image_base64
    }

    if doc_type:
        payload["typealias"] = doc_type

    headers = {
        'Authorization': f'Bearer {access_token}',
        'Content-Type': 'application/json'
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()

        result = response.json()

        if result['isSuccesful']:
            ocr_result = result['ocrResult']
            print(f"✓ Extração realizada com sucesso!")
            print(f"Tipo reconhecido: {ocr_result['typeRecognized']}")
            print(f"Campos extraídos: {len(ocr_result['fields'])}")
            print("\nDados extraídos:")

            for field in ocr_result['fields']:
                print(f"  {field['name']}: {field['value']} "
                      f"(confiança: {field['confidence']}%)")

            return ocr_result
        else:
            print(f"✗ Erro na extração: {result.get('error')}")
            return None

    except requests.exceptions.RequestException as e:
        print(f"✗ Erro na requisição: {e}")
        raise

# Uso
if __name__ == "__main__":
    token = "seu_access_token_aqui"
    data = extract_document_data(token, "./documento_rg.jpg", "RG")

import java.io.*;
import java.net.http.*;
import java.net.*;
import java.nio.file.*;
import java.util.*;
import com.google.gson.*;

public class FlexExtractorClient {

    private static final String EXTRACT_URL =
        "https://hml.flexextractor.com.br/api/v2/FlexOCR/Extract/Json";

    // Classe para resposta OCR
    public static class OcrField {
        public String name;
        public String value;
        public int[] boundingBox;
        public int confidence;
    }

    public static class OcrResult {
        public String typeRecognized;
        public boolean digitalDocument;
        public List<OcrField> fields;
        public Map<String, Integer> statistics;
    }

    public static class ExtractResponse {
        public OcrResult ocrResult;
        public boolean isSuccesful;
        public int statusCode;
        public String timestamp;
        public String error;
    }

    // Converte imagem para Base64
    private static String imageToBase64(String filePath) throws IOException {
        byte[] fileContent = Files.readAllBytes(Paths.get(filePath));
        return Base64.getEncoder().encodeToString(fileContent);
    }

    // Extrai dados do documento
    public static ExtractResponse extractDocumentData(
            String accessToken,
            String imagePath,
            String docType) throws Exception {

        String imageBase64 = imageToBase64(imagePath);

        // Monta JSON do request
        Map<String, String> requestBody = new HashMap<>();
        requestBody.put("imageBase64", imageBase64);

        if (docType != null && !docType.isEmpty()) {
            requestBody.put("typealias", docType);
        }

        Gson gson = new Gson();
        String jsonBody = gson.toJson(requestBody);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(EXTRACT_URL))
            .header("Authorization", "Bearer " + accessToken)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        ExtractResponse result = gson.fromJson(
            response.body(),
            ExtractResponse.class
        );

        if (result.isSuccesful) {
            System.out.println("✓ Extração realizada com sucesso!");
            System.out.println("Tipo: " + result.ocrResult.typeRecognized);
            System.out.println("Campos: " + result.ocrResult.fields.size());
            System.out.println("\nDados extraídos:");

            for (OcrField field : result.ocrResult.fields) {
                System.out.printf("  %s: %s (confiança: %d%%)\n",
                    field.name, field.value, field.confidence);
            }
        } else {
            System.err.println("✗ Erro: " + result.error);
        }

        return result;
    }

    public static void main(String[] args) {
        try {
            String token = "seu_access_token_aqui";
            extractDocumentData(token, "./documento_rg.jpg", "RG");
        } catch (Exception e) {
            System.err.println("Erro: " + e.getMessage());
        }
    }
}

<?php

function imageToBase64($filePath) {
    $imageData = file_get_contents($filePath);
    return base64_encode($imageData);
}

function extractDocumentData($accessToken, $imagePath, $docType = null) {
    $url = 'https://hml.flexextractor.com.br/api/v2/FlexOCR/Extract/Json';

    // Converte imagem para Base64
    $imageBase64 = imageToBase64($imagePath);

    // Monta payload
    $payload = [
        'imageBase64' => $imageBase64
    ];

    if ($docType) {
        $payload['typealias'] = $docType;
    }

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $accessToken,
        'Content-Type: application/json'
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $result = json_decode($response, true);

    if ($result['isSuccesful']) {
        $ocrResult = $result['ocrResult'];
        echo "✓ Extração realizada com sucesso!\n";
        echo "Tipo: {$ocrResult['typeRecognized']}\n";
        echo "Campos: " . count($ocrResult['fields']) . "\n\n";
        echo "Dados extraídos:\n";

        foreach ($ocrResult['fields'] as $field) {
            echo "  {$field['name']}: {$field['value']} ";
            echo "(confiança: {$field['confidence']}%)\n";
        }

        return $ocrResult;
    } else {
        echo "✗ Erro: {$result['error']}\n";
        return null;
    }
}

// Uso
$token = 'seu_access_token_aqui';
extractDocumentData($token, './documento_rg.jpg', 'RG');
?>

package main

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

type OcrField struct {
    Name        string  `json:"name"`
    Value       string  `json:"value"`
    BoundingBox []int   `json:"boundingBox"`
    Confidence  int     `json:"confidence"`
}

type OcrResult struct {
    TypeRecognized   string               `json:"typeRecognized"`
    DigitalDocument  bool                 `json:"digitalDocument"`
    Fields           []OcrField           `json:"fields"`
    Statistics       map[string]int       `json:"statistics"`
}

type ExtractResponse struct {
    OcrResult   OcrResult `json:"ocrResult"`
    IsSuccesful bool      `json:"isSuccesful"`
    StatusCode  int       `json:"statusCode"`
    Timestamp   string    `json:"timestamp"`
    Error       string    `json:"error,omitempty"`
}

func imageToBase64(filePath string) (string, error) {
    data, err := os.ReadFile(filePath)
    if err != nil {
        return "", err
    }
    return base64.StdEncoding.EncodeToString(data), nil
}

func extractDocumentData(accessToken, imagePath, docType string) (*ExtractResponse, error) {
    url := "https://hml.flexextractor.com.br/api/v2/FlexOCR/Extract/Json"

    imageBase64, err := imageToBase64(imagePath)
    if err != nil {
        return nil, err
    }

    payload := map[string]string{
        "imageBase64": imageBase64,
    }

    if docType != "" {
        payload["typealias"] = docType
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", "Bearer "+accessToken)
    req.Header.Set("Content-Type", "application/json")

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result ExtractResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }

    if result.IsSuccesful {
        fmt.Println("✓ Extração realizada com sucesso!")
        fmt.Printf("Tipo: %s\n", result.OcrResult.TypeRecognized)
        fmt.Printf("Campos: %d\n\n", len(result.OcrResult.Fields))
        fmt.Println("Dados extraídos:")

        for _, field := range result.OcrResult.Fields {
            fmt.Printf("  %s: %s (confiança: %d%%)\n",
                field.Name, field.Value, field.Confidence)
        }
    } else {
        fmt.Printf("✗ Erro: %s\n", result.Error)
    }

    return &result, nil
}

func main() {
    token := "seu_access_token_aqui"
    _, err := extractDocumentData(token, "./documento_rg.jpg", "RG")
    if err != nil {
        fmt.Printf("Erro: %v\n", err)
    }
}