Behandle e-postvedlegg automatisk

Innkommende e-poster inneholder ofte dokumenter som vedlegg – bilder, PDF-er, noen ganger nestede .eml- eller .msg-filer. I vårt advokatfirma kunne en enkelt klient-e-post inneholde et dusin bilder av en ulykkesrapport, en PDF-utredning og en videresendt e-post med egne vedlegg. En e-postvedlegg-behandlings-API som ekstraherer hvert vedlegg, validerer og leder det til riktig pipeline, ville spare timevis med manuelt arbeid.

Bilder må sendes videre til dokumentekstraksjon eller OCR, PDF-er til sammenslåing eller komprimering – og nestede e-poster må behandles rekursivt.

Hvorfor en egen e-postvedlegg-behandlingsløsning tar uker

Den som vil bygge dette selv, oppdager raskt at parsing av .eml og .msg krever mail-parser, extract-msg eller lignende. Deretter må MIME dekodes, nestede meldinger behandles, binærdata ekstraheres, formater gjenkjennes (magika, filsignaturer), virussjekkes og forgrenes etter bilde-/PDF-logikk. Hvert trinn har sine egne feilkilder: defekte headere, kodinger og nestede e-poster med egne vedlegg. Å bygge en robust e-postvedlegg-behandlings-API internt tar uker.

Hvordan MaraDocs e-postvedlegg-behandlings-API løser dette på minutter

MaraDocs API validerer .eml- og .msg-filer i ett enkelt kall. Man får strukturerte vedlegg-handles – hver med typeinformasjon. Derfra kan man forgrene etter bilde- eller PDF-operasjoner: validere etter type, deretter bruke dokumentekstraksjon, OCR, komposisjon eller komprimering. API-et støtter rekursiv behandling av e-poster som er vedlagt i e-poster.

Arbeidsflyt for e-postvedlegg-behandling: Last opp, validér, ekstrahér, viderefør

Last opp e-postfil, kall email.validate. Svaret inneholder vedlegg-handles – hver med innholdstype og metadata. For hvert vedlegg sjekk typen (bilde, PDF eller nestet e-post). Validér vedlegget med img.validate eller pdf.validate, deretter lenk sammen i pipeline: flow.ocrImg for bilder, pdf.compose for å slå sammen PDF-er, pdf.optimize for komprimering. Nestede e-poster kan valideres på nytt for å ekstrahere deres vedlegg rekursivt. Hele pipelinen kjører serversiden; handles sendes mellom trinnene uten å laste ned og laste opp på nytt.

Hva som skiller MaraDocs: Workspaces, webvisning og tysk personvernlovgivning

De fleste dokument-API-er tvinger deg til å laste ned hvert vedlegg, laste det opp et annet sted på nytt og spore identiteter over flere trinn. Med MaraDocs lever alle filer – e-posten og dens vedlegg – i samme workspace. Validér e-post, iterer gjennom vedlegg-handles og send dem til img/pdf/flow-endepunkter. Handles flyter; data forblir serversiden. Ingen nedlastings-opplastingssykluser for hvert vedlegg.

Hvis en nestet e-post har en uventet struktur eller et vedlegg må sjekkes manuelt, kan app.maradocs.io åpnes med workspace-secret for å inspisere og omorganisere filer. Brukere får full manuell kontroll når automatiseringen når sine grenser.

Behandlingen skjer i Tyskland (Maramia GmbH), med kryptering i hvile og under overføring. Workspaces utløper etter 7 dager. Ingen data forlater EU. For personvernsensitiv e-postbehandling er dette relevant.

TypeScript-kode for å ekstrahere e-postvedlegg

API-referanse: data/upload, email/validate, img/validate, pdf/validate, flow.ocrImg, data/download/pdf

import { MaraDocsClient } from "@maramia/maradocs-sdk-ts";
import { okEmail } from "@maramia/maradocs-sdk-ts/models/email";
import { okImg } from "@maramia/maradocs-sdk-ts/models/img";
import { okPdf } from "@maramia/maradocs-sdk-ts/models/pdf";

const client = new MaraDocsClient({ workspaceSecret: workspace_secret });

// Last opp og validér e-post
const uploaded = await client.data.upload(emailFile);
const validated = await client.email.validate({
  unvalidated_file_handle: uploaded.unvalidated_file_handle,
});
const email = okEmail(validated);

const pdfHandles: string[] = [];
for (const att of email.attachments) {
  if (att.content_type?.startsWith("image/")) {
    const imgVal = await client.img.validate({
      unvalidated_file_handle: att.unvalidated_file_handle,
    });
    const imgHandle = okImg(imgVal);
    const pdfHandle = await client.flow.ocrImgHandle(imgHandle);
    pdfHandles.push(pdfHandle);
  } else if (att.content_type === "application/pdf") {
    const pdfVal = await client.pdf.validate({
      unvalidated_file_handle: att.unvalidated_file_handle,
    });
    pdfHandles.push(okPdf(pdfVal));
  }
}
// Slå sammen og last ned
const composed = await client.pdf.compose({
  pdfs: pdfHandles.map((pdf_handle) => ({ pdf_handle })),
});
const blob = await client.data.downloadPdf({ pdf_handle: composed.pdf_handle });

Python-kode for e-postvedlegg-ekstraksjon

API-referanse: data/upload, email/validate, img/validate, pdf/validate, pdf/compose, data/download/pdf

# pip install python-decouple requests
"""Extract PDF attachments from an email using MaraDocs. Set ACCOUNT_SECRET in .env or environment."""

import sys
import time
from pathlib import Path

import requests
from decouple import config

API_URL = "https://api.maradocs.io/v1"


def create_workspace() -> dict:
    """Create a workspace and return auth headers."""
    r = requests.post(
        f"{API_URL}/workspace",
        headers={"Authorization": f"Bearer {config('ACCOUNT_SECRET')}"},
        json={"subaccount": None},
    )
    ws = r.json()
    return {"Authorization": f"Bearer {ws['workspace_secret']}"}


def upload_file(path: Path, auth: dict) -> dict:
    """Upload a file via two-step flow (signed URL + S3 POST). Returns unvalidated_file_handle."""
    data = path.read_bytes()
    resp = requests.post(
        f"{API_URL}/data/upload",
        headers={**auth, "Content-Type": "application/json"},
        json={"name": path.name, "size": len(data)},
    ).json()
    requests.post(
        resp["post_url"],
        data=resp.get("post_header", {}),
        files={"file": (path.name, data, "message/rfc822")},
    )
    return resp["unvalidated_file_handle"]


def run_job(path: str, payload: dict, auth: dict, timeout: int = 60) -> dict:
    """Run a job and poll until complete. Returns the result (unwraps response if present)."""
    url = f"{API_URL}/{path}"
    r = requests.post(url, headers=auth, json=payload).json()
    job_id = r["job_id"]
    start = time.time()
    while time.time() - start < timeout:
        poll_r = requests.get(f"{url}/{job_id}", headers=auth)
        if poll_r.status_code == 200:
            return poll_r.json()
    raise TimeoutError(f"Job {path} timed out")


def pdf_handles_from_email(email_handle: dict) -> list:
    """Recursively extract all pdf_handles from an email_handle (handles nested emails)."""
    handles = []
    for att in email_handle.get("attachments", []):
        media = att.get("media_type") or {}
        mt = media.get("media_type", "") if isinstance(media, dict) else ""
        validated = att.get("validated") or {}

        if mt == "application/pdf":
            resp = validated.get("response", {})
            if pdf_h := resp.get("pdf_handle"):
                handles.append(pdf_h)
        elif mt == "message/rfc822":
            nested = (validated.get("response") or {}).get("email_handle")
            if nested:
                handles.extend(pdf_handles_from_email(nested))
    return handles


def download_pdf(pdf_handle: str, auth: dict) -> bytes:
    """Request signed URL and fetch PDF bytes."""
    r = requests.post(
        f"{API_URL}/data/download/pdf",
        headers=auth,
        json={"pdf_handle": pdf_handle},
    )
    info = r.json()
    dl = requests.get(info["url"], headers=info.get("headers", {}))
    return dl.content


def main() -> None:
    email_path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("input_email.eml")
    auth = create_workspace()
    handle = upload_file(email_path, auth)
    email_data = run_job("email/validate", {"unvalidated_file_handle": handle}, auth)
    email_handle = email_data["response"]["email_handle"]
    pdf_handles = pdf_handles_from_email(email_handle)

    if not pdf_handles:
        sys.exit("No PDF attachments found")

    composed = run_job(
        "pdf/compose",
        {"pdfs": [{"pdf_handle": h} for h in pdf_handles]},
        auth,
    )
    pdf_handle = composed["pdf_handle"]
    Path("attachments.pdf").write_bytes(download_pdf(pdf_handle, auth))
    print("attachments.pdf created")


if __name__ == "__main__":
    main()

Oppsummering og neste trinn

En e-postvedlegg-behandlings-API som ekstraherer, validerer og viderefører vedlegg, er tilgjengelig. MaraDocs håndterer virusskanning, formatgjenkjenning og rekursiv e-postparsing. For fullstendig automatisering kombiner med dokumentskanner, PDF-behandling og tekstgjenkjenning.

---

Prøv nå: MaraDocs API | TypeScript SDK

---