Content Center

Build push-based integrations that upload files to Mindtickle Content Center, run content management jobs, and manage synced root folders.

View as Markdown

The Content Center APIs for synced content let you build custom integrations between Mindtickle Content Center and your external content management system (CMS) or digital asset management (DAM) platform. Use these endpoints to securely upload files, initiate content management jobs to synchronize assets, monitor execution history, and permanently delete synced root folders.

Key capabilities

Integration setup: Establish a persistent connection between your external source and a root folder in Content Center.
Secure file upload: Generate secure, temporary URLs to safely transfer files before processing.
Job execution and monitoring: Trigger content management jobs to create or update assets and track their status asynchronously using unique execution IDs.
Lifecycle management: Audit sync history or permanently delete synced root folders when integrations are no longer needed.

Prerequisites and shared context

To interact with these APIs, you must be familiar with the following platform standards:

Authentication: How to generate and use your Bearer token.
Base URLs: Determining the correct region-specific base URL for your account.
Rate limits: Understanding platform quotas and retry logic.
Conventions: Standard JSON data formats and HTTP status codes.

For more information, see Authentication and setup.

In this category

Integration: connect an external system to a root folder in Content Center and manage its lifecycle.
- Create an integration: establish a persistent connection between your external CMS or DAM and Content Center, and generate the integration_id and root_folder_id.
- Get executions for an integration: retrieve a paginated list of all content management job executions for an integration ID.
- Delete a synced root folder: permanently remove a synced root folder and all its content from Content Center.
Files: transfer files to Content Center before a job processes them.
- Get an upload URL: obtain a secure, temporary URL for uploading a file to the server.
Jobs: run and monitor content management jobs.
- Initiate a content management job: start a job that processes and synchronizes uploaded content.
- Check content management job status: monitor the progress and final outcome of a job using its execution_id.

The endpoints are typically used in this sequence: create an integration, get an upload URL, upload the file, initiate a content management job, check the job status, and then review executions. Deleting the synced root folder is a separate cleanup operation, not a routine step after a successful sync.

Key concepts

Integration: Represents a connection between your source system and Content Center, creating a root folder within Content Center.
Entity: Refers to a file or folder to be managed.
Content management job: A process for performing operations (create, update, delete) on entities.
Execution ID: A unique identifier used to track a specific content management job.

Entity object reference

The Entity object is a key component used when initiating sync jobs.

Field	Type	Required	Description
`id`	string	Required	Unique identifier for an entity in a request. Required for mapping the response.
`file_id`	string	Optional	Internal file identifier. Used for update and upsert operations.
`path`	string	Conditional	Destination path in Content Center. Required if `parent_folder_id` is omitted.
`parent_folder_id`	string	Conditional	ID of the parent folder in Content Center. Required if `path` is omitted.
`operation`	string	Required	Action to perform on the file: `UPSERT`, `DELETE`.
`external_id`	string	Optional	External ID of the file.
`upload_key`	string	Required	Key of the uploaded file.
`metadata`	object	Required	Contains file metadata.
`metadata.file_name`	string	Required	File name displayed in Content Center.
`metadata.source_path`	string	Required	Web-accessible URL of the original file.
`metadata.additional_properties`	object	Optional	Any additional properties to store with the file.

Validation: Either path or parent_folder_id must be provided.
Operation-specific requirements: The examples cover UPSERT. Before submitting a DELETE job, confirm its required fields with Mindtickle Support, including whether to include upload_key and metadata.

Request and response metadata

RequestMeta object

Used when initiating a sync job.

Field	Type	Required	Description
`integration_id`	string	Required	ID of the integration created earlier.
`root_folder_id`	string	Required	ID of the root folder created in Content Center.

EntityStatus object

Returned when checking a sync job status.

Field	Type	Description
`external_id`	string	External identifier for the entity.
`file_id`	string	Internal file identifier.
`status`	string	Status of the content management operation. See Check content management job status.

Common errors

Status	Error	Reason
`400 Bad Request`	`MALFORMED_REQUEST`	File name cannot be empty.
`400 Bad Request`	`MALFORMED_REQUEST`	File name cannot be more than 250 characters.
`400 Bad Request`	`MALFORMED_REQUEST`	`[integrationId]` cannot be empty. Provide a valid `[integrationId]` in the request.
`401 Unauthorized`	`UNAUTHORIZED`	Authorization `[bearer]` token is invalid or missing.
`429 Too Many Requests`	`RATE_LIMIT_EXCEEDED`	Too many requests.
`500 Internal Server Error`	`INTERNAL_SERVER_ERROR`	Internal server error occurred.

Usage examples

Complete workflow example

Use the regional base URL that issued your token. Replace ACCESS_TOKEN with that token and use the IDs, upload URLs, and upload keys returned by your own requests. The IDs and paths below are illustrative.

Create an integration.

POST /services/data/v1.0/content/integration

{
  "source_name": "AEM_DAM",
  "root_folder_name": "Marketing Content"
}

curl --location 'https://api.mindtickle.com/services/data/v1.0/content/integration' \
--header 'Authorization: Bearer ACCESS_TOKEN' \
--header 'Content-Type: application/json' \
--data '{
    "source_name": "AEM_DAM",
    "root_folder_name": "Marketing Content"
}'

Get an upload URL for the first file. Repeat this request and the upload step for every file in the job.

GET /services/data/v1.0/content/upload-url?file_name=annual-report-2025.pdf

curl --location 'https://api.mindtickle.com/services/data/v1.0/content/upload-url?file_name=annual-report-2025.pdf' \
--header 'Authorization: Bearer ACCESS_TOKEN'

Upload the file with a PUT request to the pre-signed URL returned in the previous step. Use that URL exactly as returned, even when it has a different host. Do not send your Mindtickle Bearer token to the upload host.

curl --location --request PUT 'PRESIGNED_URL' \
--header 'Content-Type: application/pdf' \
--data-binary '@/path/to/annual-report-2025.pdf'

Initiate the sync job. Set integration_id and root_folder_id to the values returned in step 1. Set each upload_key to the key returned for that file in step 2.

POST /services/data/v1.0/content/management

{
  "request_meta": {
    "integration_id": "int-123456",
    "root_folder_id": "folder-789012"
  },
  "entities": [
    {
      "id": "report-001",
      "operation": "UPSERT",
      "path": "reports/annual",
      "upload_key": "path/to/uploaded/file",
      "metadata": {
        "file_name": "Annual Report 2025.pdf",
        "source_path": "https://cms.example.com/reports/2025/annual.pdf"
      }
    },
    {
      "id": "doc-002",
      "operation": "UPSERT",
      "path": "marketing/brochures",
      "upload_key": "path/to/uploaded/file2",
      "metadata": {
        "file_name": "Q4-2024-Brochure-Updated.pdf",
        "source_path": "https://source-system.example.com/brochures/Q4-2024-updated.pdf"
      }
    }
  ]
}

Check the sync status using the execution_id returned in step 4.

GET /services/data/v1.0/content/management/exec-456789

Multiple operations in one sync job

Add each operation as a separate object in the entities array. The complete workflow example above includes 2 UPSERT operations, each with its own id, upload_key, destination path, and metadata. Upload each file before submitting the job.

Rate limits and quotas

The API implements rate limiting to ensure fair usage and system stability. When rate limits are exceeded, the API returns a 429 Too Many Requests status code. See Rate limits.

Best practices

Error handling: Check HTTP status codes and job outcomes. Respect Retry-After and use bounded exponential backoff for retryable failures. Before resubmitting a write after a timeout or 5xx response, check whether the original operation completed. Log request or execution IDs and error details without tokens, signed URLs, or confidential content.
Performance optimization: Batch related operations in a single sync job when possible, and perform status checks efficiently by not polling too frequently.
Security: Use HTTPS for all API calls.
Integration management: Create logical separation between different source systems, and use consistent naming conventions for integrations.

Troubleshooting

File upload failures: Ensure file names are under 250 characters and include valid extensions, check that the file size is not too large, and verify the upload is using an HTTP PUT request to the provided pre-signed URL.
Sync failures: Double-check that all required fields are provided in the request, verify file_id values for UPSERT and DELETE operations, and confirm that the integration_id and root_folder_id are valid.
Status checking issues: Ensure you are using the correct execution_id, and remember that large sync jobs may take time to complete.