Skip to main content
POST
/
knowledge
/
{folderId}
Upload a file to a knowledge folder
curl --request POST \
  --url https://api.langdock.com/knowledge/{folderId} \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: multipart/form-data' \
  --form file='@example-file' \
  --form 'url=<string>'
Using our API via a dedicated deployment? Just replace api.langdock.com with your deployment’s base URL: <deployment-url>/api/public
Uploads a new file to a specified knowledge folder. The file will be processed, embedded, and made available for semantic search.
Requires an API key with the KNOWLEDGE_FOLDER_API scope. The knowledge folder must be shared with the API key. See Share Knowledge Folders with the API for setup instructions.

​
Request Format

This endpoint accepts multipart/form-data requests with the file attached.

​
Path Parameters

ParameterTypeRequiredDescription
folderIdstringYesThe ID of the knowledge folder

​
Form Fields

FieldTypeRequiredDescription
filefileYesThe file to upload (max 256MB)
urlstringNoOptional source URL to associate with the file

​
Supported File Types

Knowledge folders support the following document types:
  • PDF (.pdf)
  • Word documents (.doc, .docx)
  • Text files (.txt)
  • Markdown (.md)
  • HTML (.html)
  • CSV (.csv)
  • PowerPoint (.pptx, .ppt)
Executable files and other potentially dangerous file types are blocked for security reasons.

​
Examples

​
Upload a File with cURL

curl -X POST "https://api.langdock.com/knowledge/{folderId}" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@/path/to/document.pdf"

​
Upload a File with JavaScript

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

async function uploadFile(folderId, filePath) {
  const form = new FormData();
  form.append("file", fs.createReadStream(filePath));

  const response = await axios.post(
    `https://api.langdock.com/knowledge/${folderId}`,
    form,
    {
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        ...form.getHeaders(),
      },
    }
  );

  return response.data;
}

​
Upload with Source URL

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

async function uploadFileWithUrl(folderId, filePath, sourceUrl) {
  const form = new FormData();
  form.append("file", fs.createReadStream(filePath));
  form.append("url", sourceUrl);

  const response = await axios.post(
    `https://api.langdock.com/knowledge/${folderId}`,
    form,
    {
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        ...form.getHeaders(),
      },
    }
  );

  return response.data;
}

​
Response Format

​
Success Response (200 OK)

{
  status: "success";
  result: {
    id: string;          // Unique attachment ID
    name: string;        // Original filename
    mimeType: string;    // MIME type of the file
    createdAt: string;   // ISO 8601 timestamp
    updatedAt: string;   // ISO 8601 timestamp
    url: string | null;  // Source URL if provided
  };
}

​
Example Response

{
  "status": "success",
  "result": {
    "id": "att_abc123def456",
    "name": "quarterly-report.pdf",
    "mimeType": "application/pdf",
    "createdAt": "2025-01-15T10:30:00.000Z",
    "updatedAt": "2025-01-15T10:30:00.000Z",
    "url": null
  }
}

​
Error Handling

try {
  const response = await uploadFile(folderId, filePath);
} catch (error) {
  if (error.response) {
    switch (error.response.status) {
      case 400:
        console.error("Invalid request:", error.response.data.message);
        // Possible causes: missing file, unsupported file type, invalid folder ID
        break;
      case 401:
        console.error("Invalid or missing API key");
        break;
      case 403:
        console.error("API key does not have access to this knowledge folder");
        break;
      case 404:
        console.error("Knowledge folder not found");
        break;
      case 408:
        console.error("Upload request timed out");
        break;
      case 413:
        console.error("File size exceeds 256MB limit");
        break;
      case 429:
        console.error("Rate limit exceeded");
        break;
      case 500:
        console.error("Server error");
        break;
    }
  }
}

​
Processing Status

After upload, the file is processed asynchronously. Use the Retrieve Files endpoint to check processing status. The syncStatus field indicates the current state:
  • UPLOADING - File is being uploaded
  • UPLOADED - File is uploaded and queued for processing
  • EXTRACTING - Text is being extracted from the file
  • EMBEDDING - Embeddings are being generated
  • SYNCED - File is ready for search
  • ACTION_FAILED, EXTRACTION_FAILED, EMBEDDING_FAILED, TIMEOUT - Processing failed

​
Async Upload Variant

For large files or when you don’t need to wait for the upload response, you can use the async upload endpoint: 
POST /knowledge/{folderId}/upload-async
This endpoint accepts the same parameters but returns immediately after the file is received, without waiting for initial processing to begin. Use this when uploading many files in batch or when upload latency is critical.
Langdock intentionally blocks browser-origin requests to protect your API key and ensure your applications remain secure. For more information, please see our guide on API Key Best Practices.

Authorizations

​
Authorization
string
header
required

API key as Bearer token. Format "Bearer YOUR_API_KEY"

Path Parameters

​
folderId
string
required

The ID of the knowledge folder

Body

multipart/form-data
​
file
file

The file to upload

​
url
string

The associated URL

Response

200

File uploaded successfully