ForHosting KIT · Documents & PDF

Remove PDF metadata

Every PDF carries a quiet passenger of information you never typed on the page: the author's real name, the software that produced it, the company account it was saved under, sometimes even the timezone of the machine that touched it last. This remove PDF metadata API strips that trail clean before a file ever leaves your hands, turning an unintentional disclosure into a non-issue.

● StablePer request + per document$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

The leak nobody notices

A PDF exported from a word processor or design tool doesn't just contain pages — it embeds a document information dictionary and, often, XMP metadata: author name, organization, the exact software version, creation and modification timestamps, sometimes a custom title someone typed years ago and forgot about. Legal teams redact a paragraph and still ship a file whose properties reveal the drafting attorney's name; a freelancer sends a proposal that quietly credits a previous client's company as the document's origin. None of this is malicious, it's just how document formats have worked for thirty years, and it is exactly what this endpoint erases.

What the cleaning pass actually touches

Call POST /pdf/metadata-clean with your file and get a task_id back immediately, since processing happens asynchronously. The engine clears the standard Info dictionary fields — Author, Title, Subject, Keywords, Creator, Producer — and removes embedded XMP packets that duplicate or extend that same identifying data. Page content, text, images, form fields and layout are left completely untouched; only the invisible properties layer is rewritten, so the document reads and prints exactly as before.

Where metadata sneaks in from

Most metadata isn't added on purpose. It comes from whatever tool built the file: word processors stamp the logged-in user as author, PDF printers embed the producer software and version, scanners record device serial numbers in some workflows, and every save-as-PDF operation can layer on a new modification timestamp while leaving the original creation date intact underneath. Over the life of a document that has passed through several hands, that history quietly stacks up, which is why a single cleaning pass at the end of a workflow matters more than trying to configure every upstream tool.

Who reaches for this and when

It fits naturally right before a file is sent externally: attached to a public tender, uploaded to a data room, published as a downloadable resource, or handed to opposing counsel. It also belongs in any pipeline that generates PDFs programmatically, since generated files often carry the name of the internal service account or library that built them. Running it as the last step in an automation, right after generation or before delivery, means metadata never has a chance to travel further than intended.

Delivery and pricing

The cleaned file arrives through a signed webhook, recommended for automated pipelines, or a signed link valid for 24 hours; both source and output are deleted after the retention window and are never used to train anything. Pricing is a flat $0.002 per request, and a task that fails after its retry attempts is never billed. This endpoint is live now and ready for production traffic.

What you can do with it

Scrub a legal filing before public disclosure

Strip the drafting attorney's name and firm software details from a redacted PDF before it becomes part of the public court record.

Prepare RFP or tender documents for release

Remove internal author names and company identifiers from a proposal document before it goes out to competing bidders or a public portal.

Sanitize generated reports at scale

Run every PDF produced by an internal reporting service through the endpoint so none of them reveal the service account or library that built them.

Clean freelance or agency deliverables

Strip a previous client's name from document properties before repurposing a template, so the next client never sees who the file was originally made for.

FAQ

How do I remove metadata from a PDF using an API?

Send the file to POST /pdf/metadata-clean, which returns a task_id right away. The cleaned PDF, stripped of author, title, producer and other identifying fields, arrives by webhook or signed link once processing completes.

Is the remove PDF metadata API free?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

Does cleaning metadata change the PDF's content or layout?

No. Only the invisible Info dictionary and embedded XMP metadata are removed; text, images, form fields and page layout stay exactly as they were.

Does this remove GPS or location data from a PDF?

It clears the standard document metadata fields and embedded XMP packets, which is where location and device data typically live in a PDF; there is no separate visible location layer to strip out.

Can I clean metadata from many PDFs in bulk?

Yes. Each call is an independent asynchronous task, so you can submit large batches in parallel and collect each cleaned file by webhook as it finishes.

Will the cleaned PDF still open normally in any reader?

Yes. The file structure, content streams and fonts are untouched, so it opens, prints and searches exactly like the original in any standard PDF reader.

Is this the same as flattening or redacting a PDF?

No. Redaction removes visible content and flattening merges form fields into static content; this endpoint only clears the hidden metadata layer, leaving everything visible on the page unchanged.

Is the metadata-clean endpoint live right now?

Yes, it is live and accepting production traffic today.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/pdf/metadata-clean

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/pdf/metadata-clean \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"pdf":"https://ejemplo.com/documento.pdf"}'

const res = await fetch("https://api.kit.forhosting.com/pdf/metadata-clean", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "pdf": "https://ejemplo.com/documento.pdf"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/pdf/metadata-clean",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "pdf": "https://ejemplo.com/documento.pdf"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/pdf/metadata-clean", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"pdf":"https://ejemplo.com/documento.pdf"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"pdf":"https://ejemplo.com/documento.pdf"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/pdf/metadata-clean", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "pdf": "https://ejemplo.com/documento.pdf"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "pdf.metadata_clean",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	25
`max_pages`	200

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.
`413`	`input_too_large`	The file exceeds the size limit.

Read the full KIT documentation →