> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to the Smartling MCP server

The Smartling MCP connector routes your AI agent's tool calls to Smartling's own MCP server through Scalekit. Each user signs in to Smartling once, and Scalekit stores and refreshes their tokens, so your agent never handles credentials. It comes with 53 tools.

**Authentication:** OAuth 2.1/DCR
**Categories:** AI, Productivity
**Tools:** 53: 32 read, 5 write, 16 destructive
**Users sign in with:** OAuth
**OAuth app:** Scalekit's or your own
**Built by:** Vendor MCP
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=SMARTLINGMCP)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Smartling MCP connection

   In **AgentKit > Connections**, create a Smartling MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

   Scalekit credentials are available for Smartling MCP server, so you don't need to register an OAuth app.

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'smartlingmcp'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Smartling MCP:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'smartlingmcp_smartling_get_available_accounts_for_current_user',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "smartlingmcp"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Smartling MCP:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="smartlingmcp_smartling_get_available_accounts_for_current_user",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user signs in once. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'smartlingmcp_smartling_count_account_issues',
  toolInput: {
    account_id: '<account_id>',
  },
  connector: 'smartlingmcp',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="smartlingmcp_smartling_count_account_issues",
    tool_input={
        "account_id": "<account_id>",
    },
    connection_name="smartlingmcp",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `smartlingmcp_smartling_count_account_issues`

SmartlingCountAccountIssues · Read-only

Count issues across all projects in the current Smartling account (with optional project narrowing). The account is taken from the MCP token credentials.

# Use cases
- Show a global issue badge for the user

# Examples
- All open: issue_state_codes=["OPENED"]

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `answered` (`boolean`, optional): Filter by answered state
- `assignee_user_uid` (`string`, optional): Filter to issues assigned to this user (max 12 chars)
- `created_date_after` (`string`, optional): ISO 8601 timestamp; include issues created after this date
- `created_date_before` (`string`, optional): ISO 8601 timestamp; include issues created before this date
- `has_comments` (`boolean`, optional): Filter by whether the issue has comments
- `issue_numbers` (`array`, optional): Filter by specific issue numbers (max 1000)
- `issue_severity_level_codes` (`array`, optional): Filter by severity (LOW, MEDIUM, HIGH)
- `issue_state_codes` (`array`, optional): Filter by state (OPENED, RESOLVED)
- `issue_sub_type_codes` (`array`, optional): Filter by sub-type (CLARIFICATION, MISSPELLING, etc.)
- `issue_type_codes` (`array`, optional): Filter by type (SOURCE, TRANSLATION)
- `issue_watching_state_code` (`string`, optional): Filter by current user's watching state. One of: `WATCHING`, `NOT_WATCHING`.
- `job_filter` (`object`, optional): Filter by job containment
- `project_ids` (`array`, optional): Optional: limit to specific project UIDs
- `reopened` (`boolean`, optional): Filter by reopened state
- `reported_by_user_uid` (`string`, optional): Filter to issues reported by this user (max 12 chars)
- `resolved_date_after` (`string`, optional): ISO 8601 timestamp; include issues resolved after this date
- `resolved_date_before` (`string`, optional): ISO 8601 timestamp; include issues resolved before this date
- `string_filter` (`object`, optional): Filter by string properties

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_count_project_issues`

SmartlingCountProjectIssues · Read-only

Count issues within a single Smartling project matching the given filters.

# Use cases
- Display a badge of how many open issues a project has
- Sanity-check filter shape before running a full find

# Examples
- Count all open issues: project_id="p1", issue_state_codes=["OPENED"]

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `project_id` (`string`, required): The Smartling project UID
- `answered` (`boolean`, optional): Filter by answered state
- `assignee_user_uid` (`string`, optional): Filter to issues assigned to this user (max 12 chars)
- `created_date_after` (`string`, optional): ISO 8601 timestamp; include issues created after this date
- `created_date_before` (`string`, optional): ISO 8601 timestamp; include issues created before this date
- `has_comments` (`boolean`, optional): Filter by whether the issue has comments
- `issue_numbers` (`array`, optional): Filter by specific issue numbers (max 1000)
- `issue_severity_level_codes` (`array`, optional): Filter by severity (LOW, MEDIUM, HIGH)
- `issue_state_codes` (`array`, optional): Filter by state (OPENED, RESOLVED)
- `issue_sub_type_codes` (`array`, optional): Filter by sub-type (CLARIFICATION, MISSPELLING, etc.)
- `issue_type_codes` (`array`, optional): Filter by type (SOURCE, TRANSLATION)
- `issue_watching_state_code` (`string`, optional): Filter by current user's watching state. One of: `WATCHING`, `NOT_WATCHING`.
- `job_filter` (`object`, optional): Filter by job containment
- `reopened` (`boolean`, optional): Filter by reopened state
- `reported_by_user_uid` (`string`, optional): Filter to issues reported by this user (max 12 chars)
- `resolved_date_after` (`string`, optional): ISO 8601 timestamp; include issues resolved after this date
- `resolved_date_before` (`string`, optional): ISO 8601 timestamp; include issues resolved before this date
- `string_filter` (`object`, optional): Filter by string properties

Example input: `{"project_id":"project-123"}`

### `smartlingmcp_smartling_execute_lqa_evaluation`

SmartlingExecuteLqaEvaluation · Read-only

Run an automated Linguistic Quality Assurance (LQA) evaluation on a single translated string and get back any detected quality errors.

# What is an LQA evaluation?
LQA evaluation checks a translation against its source string using Smartling's linguistic quality
rules (e.g. blocklist compliance, omissions, mistranslations) and returns the list of errors found,
each with a category and severity. It does not modify the string or record the errors anywhere;
it only reports what an LQA scan would flag.

# Use cases
- Automatically screen a translation for quality issues right after it's produced (e.g. from MT or a translator)
- Gate a workflow step transition on the string passing LQA with no critical/major errors
- Spot-check a translation on demand without waiting for a scheduled LQA pass

# Examples
- Minimal: account_id, project_uid, hashcode, source_locale_id="en", target_locale_id="fr-FR", original_string, translation
- With job/workflow context: also pass job_uid, workflow_uid, workflow_step_uid so the evaluation is attributed to that job step
- With custom metadata: metadata={"integrationType": "TEST"}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `hashcode` (`string`, required): Hashcode of the string being evaluated. Not validated against Smartling content and does not need to correspond to an existing string; any non-empty string is accepted.
- `original_string` (`string`, required): The original (source) string text
- `project_uid` (`string`, required): The Smartling project UID the string belongs to
- `source_locale_id` (`string`, required): Locale identifier of the source string (e.g. "en")
- `target_locale_id` (`string`, required): Locale identifier of the translation (e.g. "fr-FR")
- `translation` (`string`, required): The translated text to evaluate against the source
- `job_uid` (`string`, optional): Optional: translation job UID this evaluation is associated with
- `metadata` (`object`, optional): Optional: arbitrary string key/value metadata to attach to the evaluation (e.g. {"integrationType": "TEST"})
- `word_count` (`integer`, optional): Optional: word count of the string, used for reporting/metrics
- `workflow_step_uid` (`string`, optional): Optional: workflow step UID this evaluation is associated with
- `workflow_uid` (`string`, optional): Optional: workflow UID this evaluation is associated with

Example input: `{"account_id":"<account_id>","hashcode":"<hashcode>","original_string":"<original_string>","project_uid":"project-123","source_locale_id":"en","target_locale_id":"fr-FR","translation":"<translation>"}`

### `smartlingmcp_smartling_export_glossary`

SmartlingExportGlossary · Read-only

Export glossary entries in various formats (CSV, XLSX, TBX).

# What is glossary export?
Glossary export allows you to export glossary entries with various filtering and formatting options. You can export entries in CSV, XLSX, or TBX formats with comprehensive filtering capabilities including locale filtering, entry state filtering, label filtering, and more.

# Use cases
- User requests to export entire glossary in a specific format
- User wants to export glossary entries for specific locales
- User needs to export filtered glossary entries (by state, labels, date ranges, etc.)
- User wants to export glossary in TBX format for translation memory systems
- User needs to export glossary entries with specific sorting or pagination

# Examples
- Export full glossary as CSV: {"glossary_uid": "abc123", "format": "CSV", "locale_ids": ["en-US", "fr-FR"]}
- Export active entries only: {"glossary_uid": "abc123", "format": "XLSX", "entry_state": "ACTIVE"}
- Export with custom filters: {"glossary_uid": "abc123", "format": "TBX", "tbx_version": "TBXcoreStructV02", "query": "marketing terms"}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `format` (`string`, required): Export format. CSV for comma-separated values, XLSX for Excel format, TBX for translation exchange format. One of: `CSV`, `XLSX`, `TBX`.
- `glossary_uid` (`string`, required): UID of the glossary to export entries from.
- `created_by_filter` (`object`, optional): Filter entries by creator.
- `created_filter` (`object`, optional): Filter entries by creation date.
- `dnt_locale_id` (`string`, optional): Filter entries by "Do Not Translate" flag for specified locale.
- `dnt_term_set` (`boolean`, optional): Filter entries based on "Do Not Translate" term setting.
- `entry_state` (`string`, optional): Filter entries by their state. ACTIVE for active entries only, ARCHIVED for archived entries only, BOTH for all entries. One of: `ACTIVE`, `ARCHIVED`, `BOTH`.
- `entry_uids` (`array`, optional): Array of specific entry UIDs to export. If provided, only these entries will be exported.
- `focus_locale_id` (`string`, optional): Focus locale ID for the export. This locale will be prioritized in the export.
- `labels` (`object`, optional): Filter entries by labels.
- `last_modified_by_filter` (`object`, optional): Filter entries by last modifier.
- `last_modified_filter` (`object`, optional): Filter entries by last modified date.
- `locale_ids` (`array`, optional): Array of locale IDs to include in export (e.g., ["en-US", "fr-FR", "de-DE"]). If not provided, all locales will be exported.
- `missing_translation_locale_id` (`string`, optional): Filter to include entries missing translations in specified locale.
- `paging` (`object`, optional): Pagination settings for the export.
- `present_translation_locale_id` (`string`, optional): Filter to include entries with translations present in specified locale.
- `query` (`string`, optional): Search query to filter entries by term content.
- `return_fallback_translations` (`boolean`, optional): Whether to include fallback translations in the export. Default is false.
- `skip_entries` (`boolean`, optional): Whether to skip entry details and export only metadata. Default is false.
- `sorting` (`object`, optional): Sorting settings for the export.
- `tbx_version` (`string`, optional): TBX version to use when exporting in TBX format. Only relevant when format is "TBX". One of: `TBXcoreStructV02`, `TBXcoreStructV03`.

Example input: `{"account_id":"<account_id>","format":"CSV","glossary_uid":"<glossary_uid>"}`

### `smartlingmcp_smartling_find_account_issues`

SmartlingFindAccountIssues · Read-only

Search issues across all projects in the current Smartling account, with pagination, sorting, filters, and optional project narrowing. The account is taken from the MCP token credentials.

# Use cases
- Find all HIGH-severity OPEN issues across the whole account
- Cross-project triage of recent issues

# Examples
- All open: issue_state_codes=["OPENED"]
- Narrow to two projects: project_ids=["p1","p2"]

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `answered` (`boolean`, optional): Filter by answered state
- `assignee_user_uid` (`string`, optional): Filter to issues assigned to this user (max 12 chars)
- `created_date_after` (`string`, optional): ISO 8601 timestamp; include issues created after this date
- `created_date_before` (`string`, optional): ISO 8601 timestamp; include issues created before this date
- `has_comments` (`boolean`, optional): Filter by whether the issue has comments
- `issue_numbers` (`array`, optional): Filter by specific issue numbers (max 1000)
- `issue_severity_level_codes` (`array`, optional): Filter by severity (LOW, MEDIUM, HIGH)
- `issue_state_codes` (`array`, optional): Filter by state (OPENED, RESOLVED)
- `issue_sub_type_codes` (`array`, optional): Filter by sub-type (CLARIFICATION, MISSPELLING, etc.)
- `issue_type_codes` (`array`, optional): Filter by type (SOURCE, TRANSLATION)
- `issue_watching_state_code` (`string`, optional): Filter by current user's watching state. One of: `WATCHING`, `NOT_WATCHING`.
- `job_filter` (`object`, optional): Filter by job containment
- `limit` (`integer`, optional): Page size (1–30; default 30). Default: `30`.
- `offset` (`integer`, optional): Pagination offset, non-negative
- `project_ids` (`array`, optional): Optional: limit to specific project UIDs
- `reopened` (`boolean`, optional): Filter by reopened state
- `reported_by_user_uid` (`string`, optional): Filter to issues reported by this user (max 12 chars)
- `resolved_date_after` (`string`, optional): ISO 8601 timestamp; include issues resolved after this date
- `resolved_date_before` (`string`, optional): ISO 8601 timestamp; include issues resolved before this date
- `sort_by` (`object`, optional): Sort specification
- `string_filter` (`object`, optional): Filter by string properties

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_find_project_issues`

SmartlingFindProjectIssues · Read-only

Search issues within a single Smartling project, with pagination, sorting, and rich filters.

# Use cases
- List all OPEN issues in a project, newest first
- Find HIGH-severity TRANSLATION issues assigned to a specific user
- Count + page through a project's issue backlog

# Examples
- All open issues: project_id="p1", issue_state_codes=["OPENED"]
- By assignee: assignee_user_uid="user-1"
- Sorted by creation date: sort_by={items:[{direction:"DESC", field_name:"createdDate"}]}, limit=30

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `project_id` (`string`, required): The Smartling project UID
- `answered` (`boolean`, optional): Filter by answered state
- `assignee_user_uid` (`string`, optional): Filter to issues assigned to this user (max 12 chars)
- `created_date_after` (`string`, optional): ISO 8601 timestamp; include issues created after this date
- `created_date_before` (`string`, optional): ISO 8601 timestamp; include issues created before this date
- `has_comments` (`boolean`, optional): Filter by whether the issue has comments
- `issue_numbers` (`array`, optional): Filter by specific issue numbers (max 1000)
- `issue_severity_level_codes` (`array`, optional): Filter by severity (LOW, MEDIUM, HIGH)
- `issue_state_codes` (`array`, optional): Filter by state (OPENED, RESOLVED)
- `issue_sub_type_codes` (`array`, optional): Filter by sub-type (CLARIFICATION, MISSPELLING, etc.)
- `issue_type_codes` (`array`, optional): Filter by type (SOURCE, TRANSLATION)
- `issue_watching_state_code` (`string`, optional): Filter by current user's watching state. One of: `WATCHING`, `NOT_WATCHING`.
- `job_filter` (`object`, optional): Filter by job containment
- `limit` (`integer`, optional): Page size (1–30; default 30). Default: `30`.
- `offset` (`integer`, optional): Pagination offset, non-negative
- `reopened` (`boolean`, optional): Filter by reopened state
- `reported_by_user_uid` (`string`, optional): Filter to issues reported by this user (max 12 chars)
- `resolved_date_after` (`string`, optional): ISO 8601 timestamp; include issues resolved after this date
- `resolved_date_before` (`string`, optional): ISO 8601 timestamp; include issues resolved before this date
- `sort_by` (`object`, optional): Sort specification
- `string_filter` (`object`, optional): Filter by string properties

Example input: `{"project_id":"project-123"}`

### `smartlingmcp_smartling_get_available_accounts_for_current_user`

SmartlingGetAvailableAccountsForCurrentUser · Read-only

Get available accounts for the current user.

# What are available accounts?
Available accounts are Smartling accounts that the current authenticated user has access to. This tool is essential for determining which account UID to use with other Smartling MCP tools.

# Use cases
- User needs to determine which account UID to use before calling other Smartling tools
- User wants to see all accounts they have access to
- User needs to select the correct account context for their operations
- Required before using other Smartling MCP tools that need accountUid parameter

# Important Notes
- This tool must be used before other Smartling MCP tools that require accountUid parameter
- If the tool returns more than 1 account UID, the user will be asked to specify which one to use
- The account UID from this response should be used in subsequent tool calls

# Examples
- Get available accounts: Use without any parameters
- Account selection: If multiple accounts are returned, user must choose which account UID to use

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `smartlingmcp_smartling_get_glossary`

SmartlingGetGlossary · Read-only

Retrieve a specific glossary from the current Smartling account by its UID.

# What is glossary?
A Glossary is a list of terms and expressions that represent your brand, and influence your translations.
Companies create Glossaries in order to provide a shared understanding of terms to be used across all business units and languages.
With Smartling, you will be able to utilize the Glossary to synchronize translations across all responsible parties working on your translations.

# Use cases
- User requests to get detailed information about a specific glossary
- Resolving glossary(s) by project:
  - If you have only project name then you can chain next tools to get glossaries uids: smartling_list_projects -> smartling_get_project -> smartling_get_linguistic_package (glossaries uids might be inside linguistic package) -> smartling_list_glossaries or smartling_get_glossary.
  - If you have project uid then you can chain next tools to get glossaries uids: smartling_get_project -> smartling_get_linguistic_package (glossaries uids might be inside linguistic package) -> smartling_list_glossaries or smartling_get_glossary.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `glossary_uid` (`string`, required): UID of the glossary to retrieve.

Example input: `{"account_id":"<account_id>","glossary_uid":"<glossary_uid>"}`

### `smartlingmcp_smartling_get_issue`

SmartlingGetIssue · Read-only

Retrieve detailed information about a specific string issue.

# What is a string issue?
A string issue is a question, clarification request, or quality flag raised against a specific string (source or translation) inside a Smartling project.

# Use cases
- Inspect the full state of one issue by its UID
- Read severity, type, comments count, and assignee on a single issue

# Examples
- Get an issue: project_id="abc123", issue_uid="issue-uid-1"

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `issue_uid` (`string`, required): The unique identifier of the issue to retrieve
- `project_id` (`string`, required): The Smartling project UID the issue belongs to

Example input: `{"issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_get_issue_comment`

SmartlingGetIssueComment · Read-only

Retrieve a single issue comment by UID.

# Use cases
- Read the full text of one specific comment

# Examples
- project_id="p1", issue_uid="i1", issue_comment_uid="c1"

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `issue_comment_uid` (`string`, required): The comment UID
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_comment_uid":"<issue_comment_uid>","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_get_job`

SmartlingGetJob · Read-only

Get detailed information about a specific Smartling job by its UID.

# What is a job?
A job is a translation task that contains files to be translated. Jobs help organize and manage translation work by grouping files together with specific target languages, due dates, and workflow requirements.

# Use cases
- User requests to get detailed information about a specific job
- User needs to see comprehensive job details including source files, custom fields, and metadata
- User wants to retrieve job priority, callback configuration, and user details
- User needs to understand job creation and modification history

# Examples
- Get job by UID: Provide project_id and job_uid parameters
- Retrieve job details: Returns complete job configuration with priority, source files, and custom fields
- Check job progress: View job status, creation date, due date, and completion dates

# Job Details Response
The response includes extended job information beyond the basic job list:
- Job priority level
- Array of source files in the job
- Callback method and URL configuration
- Creation and modification user details
- Custom field values
- Complete job metadata and timestamps

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `job_uid` (`string`, required): The unique identifier of the job to retrieve (e.g., "job-uid-123", "translation-job-456")
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")

Example input: `{"job_uid":"job-uid-123","project_id":"project-123"}`

### `smartlingmcp_smartling_get_job_history`

SmartlingGetJobHistory · Read-only

Get the audit history of a specific Smartling job.

# What is job history?
Job history is the chronological audit trail of everything that has happened
to a job: creation, status changes, content additions/removals, due date
changes, priority changes, and rush request create/remove events. Each entry
records the action, when it started/ended, who (if anyone) performed it, and
event-specific details.

# Use cases
- User wants to know who changed a job's due date or priority, and when
- User needs to see when content was added to or removed from a job
- User wants an audit trail of status changes for a job
- User is investigating unexpected job behavior and needs the sequence of events

# Examples
- Get recent history: Provide project_id and job_uid (returns up to 100 most recent entries)
- Page through longer histories: Use offset with limit to retrieve subsequent pages, guided by totalCount in the response

# Pagination
- limit: Page size, 1-100 (default 100 if omitted)
- offset: Zero-based offset into the history (default 0 if omitted)
- totalCount in the response tells you how many entries exist in total

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `job_uid` (`string`, required): The unique identifier of the job to retrieve history for (e.g., "job-uid-123")
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `limit` (`integer`, optional): (Optional) Page size (1-100; default 100). Capped at 100 to keep responses manageable; use offset to page through longer histories.
- `offset` (`integer`, optional): (Optional) Pagination offset, non-negative. Defaults to 0 if omitted.

Example input: `{"job_uid":"job-uid-123","project_id":"project-123"}`

### `smartlingmcp_smartling_get_linguistic_package`

SmartlingGetLinguisticPackage · Read-only

Retrieve a specific linguistic package from the current Smartling account by its UID.

# What is linguistic package?
A linguistic package is a collection of translation resources, including glossaries and style guides that are used to ensure consistent and accurate translations.
This bundle contains settings that determine which linguistic assets (glossaries, style guides) are provided to translators for your projects.

# Use cases
- User requests to get detailed information about a specific linguistic package.
- Resolving linguistic package by project:
  - If you have only project name then you can chain next tools to get linguistic package: smartling_list_projects -> smartling_get_project -> smartling_get_linguistic_package.
  - If you have project uid then you can chain next tools to get linguistic package: smartling_get_project -> smartling_get_linguistic_package.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `linguistic_package_uid` (`string`, required): UID of the linguistic package to retrieve.

Example input: `{"account_id":"<account_id>","linguistic_package_uid":"<linguistic_package_uid>"}`

### `smartlingmcp_smartling_get_project`

SmartlingGetProject · Read-only

Retrieve a specific project from the current Smartling account by its UID.

# What is project?
A project is a translation environment for the various types of content user wants to translate.

# Use cases
- User requests to get detailed information about a specific project.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `project_uid` (`string`, required): UID of the project to retrieve.

Example input: `{"project_uid":"project-123"}`

### `smartlingmcp_smartling_get_styleguide`

SmartlingGetStyleguide · Read-only

Get specific style guide by its unique identifier.

# What is styleguide?
A Style Guide is a collection of rules about your preferences regarding content formatting, writing tone, and style.
It is a tool for ensuring the language and tone of your brand is found accurate and consistent in your translations.

# Use cases
- User requests to get detailed information about a specific style guide.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `style_guide_uid` (`string`, required): Unique identifier of the style guide to retrieve. Must ask user if not provided.

Example input: `{"account_id":"<account_id>","style_guide_uid":"<style_guide_uid>"}`

### `smartlingmcp_smartling_get_word_count_report`

SmartlingGetWordCountReport · Read-only

Get word count report from Smartling in CSV format for efficient analysis.

# What is word count report?
A word count report provides detailed information about word counts and weighted word counts for translation work. It includes data about projects, jobs, translation resources, agencies, locales, workflow steps, and fuzzy matching profiles.

# API Constraints
**CRITICAL**: The date range between start_date and end_date must be **less than 1 year (365 days)**. The API will return a validation error if the range exceeds this limit.

# IMPORTANT: Apply Filters to Minimize Response Size
**Always encourage users to apply as many filters as possible** to keep response size manageable:
- **project_ids**: Filter by specific projects (most important filter)
- **target_locale_ids**: Filter by specific target locales
- **job_uids**: Filter by specific jobs
- **user_uids**: Filter by specific translation resources
- **workflow_step_types**: Filter by specific workflow steps (use smartling_get_workflow_step_types tool first)
- **start_date/end_date**: Use narrow date ranges
- **fields**: Request only the columns you need (see field list below)

# Recommended Field Selection
**Minimize the number of fields in the 'fields' parameter**. Only include what's needed for the specific query:
- Minimal: "projectId,projectName,targetLocaleId,wordCount"
- With job info: "projectId,projectName,targetLocaleId,jobUid,jobName,wordCount"
- With translator: "projectId,targetLocaleId,translationResourceName,workflowStepType,wordCount"

# Examples
- Find projects with most words in French: {"start_date": "2024-01-01", "end_date": "2024-12-31", "target_locale_ids": ["fr-FR"], "fields": "projectId,projectName,wordCount"}
- Find strings in AI Review step: {"start_date": "2024-01-01", "end_date": "2024-12-31", "workflow_step_types": ["AI Review"], "fields": "projectId,jobName,workflowStepType,wordCount"}
- Translator productivity: {"start_date": "2024-01-01", "end_date": "2024-01-31", "user_uids": ["user-123"], "fields": "translationResourceName,targetLocaleId,wordCount"}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `end_date` (`string`, required): End date for the report in ISO format (e.g., 2024-01-31) in America/New_York timezone. Note: The date range (end_date - start_date) must be less than 1 year (365 days).
- `start_date` (`string`, required): Start date for the report in ISO format (e.g., 2024-01-01) in America/New_York timezone. Note: The date range (end_date - start_date) must be less than 1 year (365 days).
- `agency_uid` (`string`, optional): The unique identifier of the agency to get report for
- `fields` (`string`, optional): List of fields to include in the response, separated by commas. Possible values: accountUid, accountName, projectId, projectName, targetLocaleId, targetLocale, jobUid, jobName, jobReferenceNumber, jobNumber, translationResourceUid, translationResourceName, agencyUid, agencyName, workflowStepType, workflowStepUid, workflowStepName, fuzzyProfileName, fuzzyTier, wordCount, weightedWordCount, characterCount. If not provided, next list is recommended as default value: projectId, projectName, targetLocaleId, jobUid, jobName, translationResourceName, workflowStepType, wordCount, characterCount.
- `job_uids` (`array`, optional): List of the unique identifiers of the job to get report for
- `limit` (`number`, optional): Maximum number of items to return (default: 10000, max: 10000)
- `offset` (`number`, optional): Pagination offset (0-based)
- `project_ids` (`array`, optional): List of the unique identifiers of the Smartling project to get report for
- `target_locale_ids` (`array`, optional): List of the target locale identifiers (e.g., "es", "fr-FR") to get report for
- `user_uids` (`array`, optional): List of the unique identifiers of the translation resource/user to get report for
- `workflow_step_types` (`array`, optional): The workflow step types to filter by (e.g., "Translation", "Review", "Edit"). Entire list can be fetched using the "Get Workflow Step Types" tool

Example input: `{"account_id":"<account_id>","end_date":"<end_date>","start_date":"<start_date>"}`

### `smartlingmcp_smartling_get_workflow_step_types`

SmartlingGetWorkflowStepTypes · Read-only

Get available workflow step types from Smartling for use in reporting and filtering.

# What are workflow step types?
Workflow step types define the different stages in a translation workflow, such as "Translation", "Review", "Edit", etc. This tool retrieves the complete list of available step types that can be used for filtering in other report tools.

# Examples
- Get all available workflow step types: {} (no parameters needed)

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `smartlingmcp_smartling_list_content_assignments`

SmartlingListContentAssignments · Read-only

List content assignments for the current Smartling account.

# What is a content assignment?
A content assignment represents a unit of translation work assigned to a translator (user) or an agency
within a specific workflow step of a translation job. Each assignment ties together a project, target
locale, workflow step, translation job, and the assignee responsible for completing the work, along with
the word count and due dates relevant to that step.

# Use cases
- Discover who (translator or agency) is assigned to active translation work across the account
- Audit workflow ownership across projects, locales, and jobs
- Identify unassigned content assignments (entries where userUid and agencyUid are null)
- Review upcoming workflow-step or overall job due dates for resource planning
- Inspect word counts per workflow step for capacity planning

# Examples
- List all content assignments for the current account:
{} (no parameters)

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_list_file_jobs`

SmartlingListFileJobs · Read-only

Retrieve a list of translation jobs where a specific file is involved in a Smartling project.

Returns a list of translation jobs that include the specified file. Each job object contains job metadata (UID, status, dates).
**Special case - Unassigned strings**: If the file contains strings that are NOT assigned to any job, the response includes a special indicator object with all null values `{"jobUid":null,"dueDate":null,"createdDate":null,"status":null}`. This signals that some file content remains unassigned.

# Use cases
- Check which translation jobs contain a specific file
- Identify files with unassigned strings that need job assignment
- Diagnose why the connector doesn't deliver completed jobs (file content may span multiple incomplete jobs)

# Parameters
- project_uid: The unique identifier of the Smartling project
- file_uri: The URI of the file to check job status for

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `file_uri` (`string`, required): The URI of the file to check (e.g., "/content/app.json", "strings/mobile.properties")
- `project_uid` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")

Example input: `{"file_uri":"/content/app.json","project_uid":"project-123"}`

### `smartlingmcp_smartling_list_glossaries`

SmartlingListGlossaries · Read-only

List glossaries by set of filters.

# Use cases
- User requests to retrieve glossaries:
  - User asked to retrieve a list of all glossaries
  - User asked to search for glossaries by name or description
  - User asked to filter glossaries by state (active, archived, both)
  - User asked to look for glossary for a specific target locale
  - User asked to retrieve several glossaries by their UIDs

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `glossary_state` (`string`, optional): Glossary state. Enum: "ACTIVE" "ARCHIVED" "BOTH". One of: `ACTIVE`, `ARCHIVED`, `BOTH`.
- `glossary_uids` (`array`, optional): Filter by glossary UIDs.
- `include_entries_count` (`boolean`, optional): Allows excluding or including glossary entries count for each glossary found by the criteria.
- `query` (`string`, optional): Allows searching glossaries by query within glossaryName or description properties. Also supports exact search by glossaryUid.
- `target_locale_id` (`string`, optional): Filter glossaries that have the specified target locale preconfigured.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_list_issue_comments`

SmartlingListIssueComments · Read-only

List all comments on an issue.

# Use cases
- Read the discussion thread on an issue before responding
- Audit comment activity for a specific issue

# Examples
- project_id="p1", issue_uid="i1"

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_list_jobs`

SmartlingListJobs · Read-only

List jobs from a specific Smartling project with optional filtering.

# Use cases
- User requests to retrieve all jobs from a project
- User wants to filter jobs by name or status
- User needs to see job progress and status information
- User wants to understand what translation work is available or in progress

# Examples
- List all jobs in a project: Use only project_id parameter
- Find jobs by name: Include job_name parameter for filtering
- Filter by status: Use job_statuses parameter with specific statuses
- Find active jobs: Use job_statuses=["IN_PROGRESS","AWAITING_AUTHORIZATION"]

# Job Statuses
Available job statuses include:
- AWAITING_AUTHORIZATION: Job is waiting for approval to start
- IN_PROGRESS: Job is currently being worked on
- COMPLETED: Job has been finished
- CANCELLED: Job was cancelled before completion
- CLOSED: Job was closed after completion

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `job_name` (`string`, optional): (Optional) Filter jobs by name. Supports partial matching to find jobs containing this text.
- `job_statuses` (`array`, optional): (Optional) Filter jobs by status. Provide an array of job statuses to filter by. Example: ["IN_PROGRESS", "AWAITING_AUTHORIZATION"]

Example input: `{"project_id":"project-123"}`

### `smartlingmcp_smartling_list_linguistic_packages`

SmartlingListLinguisticPackages · Read-only

List all linguistic packages from the current Smartling account.

# Use cases
- User requests to get a list of available linguistic packages.

# Examples
- List all linguistic packages:
{"account_id": "your-account-uid"}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_list_projects`

SmartlingListProjects · Read-only

List projects from the current Smartling account by name.

# Use cases
- User requests to retrieve projects:
  - User asked to retrieve a list of all projects
  - User asked to search for projects by name
  - User asked to filter archived projects
  - User asked to look for projects with a specific project type codes
- Resolving project by project name:
  - If you have only project name then you can chain next tools to get project details: smartling_list_projects -> smartling_get_project (project list tool returns a simplified objects list with no additional information, so it needs to be followed by a get project call).

# Examples
- List all projects:
{} (no parameters)

- Find projects by name:
{
    "project_name_filter": "Mobile App"
}

- List active projects of specific type:
{
    "include_archived": false,
    "project_type_codes": ["web", "mobile"]
}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `include_archived` (`boolean`, optional): Whether to include archived projects in the list. If not provided, only active projects will be listed.
- `project_name_filter` (`string`, optional): Name of the project to filter by. If not provided, all projects will be listed. Do not enter empty string value if not provided, call tool without parameters instead. Must ask user if not provided.
- `project_type_codes` (`array`, optional): Array of project type codes to filter by. If not provided, all project types will be listed. Do not enter empty array if not provided, call tool without parameters instead. Must ask user if not provided.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_list_styleguides`

SmartlingListStyleguides · Read-only

List style guides from the current Smartling account by name.

# Use cases
- User requests to retrieve style guides:
  - User requests to retrieve all style guides.
  - User requests to retrieve style guides based on their names.

# Examples
- List all style guides:
{} (no parameters)

- Find style guides by name:
{
    "name": "Marketing"
}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `name` (`string`, optional): Name of the style guide to filter by. If not provided, all style guides will be listed. Do not enter empty string value if not provided, call tool without parameters instead. Must ask user if not provided.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_list_users`

SmartlingListUsers · Read-only

List users from a Smartling account with optional filtering.

# What are users in Smartling?
Users are individuals who have access to the Smartling platform with specific roles and permissions. They can be translators, project managers, reviewers, or other team members involved in the localization process.

# Use cases
- User requests to retrieve all users from the account
- User wants to search for specific users by name
- User needs to filter users by role or project assignment
- User wants to find users with specific status (active, pending)
- User wants to find users assigned to specific projects
- User needs to retrieve user contact information

# Examples
- List all users: Use without any parameters
- Search by name: Use keyword parameter to search in first and last names
- Filter by role: Use user_roles parameter with specific role names
- Find project users: Use project_ids parameter to find users assigned to specific projects
- Get active users: Use user_status="ACTIVE" to filter only active users

# User Statuses
Available user statuses include:
- ALL: All users regardless of status (default)
- ACTIVE: Users who are currently active
- PENDING: Users who have pending invitations

# Common Roles
Common user roles in Smartling include:
- ROLE_TRANSLATION_RESOURCE: Translation Resource
- ROLE_PROJECT_MANAGER: Project Manager
- ROLE_ACCOUNT_OWNER: Account Owner

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `keyword` (`string`, optional): (Optional) Search keyword to filter users by first or last name. The search is performed as a wildcard match.
- `project_ids` (`array`, optional): (Optional) Array of project IDs to filter users who are assigned to specific projects. Example: ["project-123", "project-456"]
- `user_roles` (`array`, optional): (Optional) Array of role names to filter users by their assigned roles. Example: ["ROLE_TRANSLATION_RESOURCE", "ROLE_PROJECT_MANAGER"]
- `user_status` (`string`, optional): (Optional) Filter users by their status. ALL (default) returns all users, ACTIVE returns only active users, PENDING returns users with pending invitations. One of: `ALL`, `ACTIVE`, `PENDING`.
- `user_uids` (`array`, optional): (Optional) Array of specific user UIDs to retrieve. Example: ["user-123", "user-456"]

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_list_workflows`

SmartlingListWorkflows · Read-only

List workflows from a specific Smartling project with optional filtering.

# What is a workflow?
A workflow in Smartling defines the translation process steps that content goes through from source to target languages. Each workflow contains steps like translation, editing, review, and publishing, with specific configurations for each step.

# Use cases
- User requests to retrieve all workflows for a project
- User wants to search workflows by keyword
- User needs to filter workflows by specific locales
- User wants to find workflows with specific UIDs or step UIDs
- User needs to understand the translation process configuration

# Important Notes
- Results are limited to the first 100 workflows to avoid response size limits
- Response includes essential workflow and step information with verbose fields removed for performance

# Examples
- List all workflows in a project:
{
    "project_id": "project-123"
}

- Search workflows by keyword:
{
    "project_id": "project-123",
    "keyword": "marketing"
}

- Filter workflows by locales:
{
    "project_id": "project-123",
    "locale_ids": ["es-ES", "fr-FR"]
}

- Find specific workflows:
{
    "project_id": "project-123",
    "workflow_uids": ["workflow-uid-1", "workflow-uid-2"]
}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `keyword` (`string`, optional): Optional keyword to search for in workflow names. Supports partial matching.
- `locale_ids` (`array`, optional): Optional array of locale identifiers to filter workflows that include these locales. Example: ["es-ES", "fr-FR", "de-DE"]
- `project_id` (`string`, optional): The unique identifier of the Smartling project to search workflows within. If not provided, returns workflows across all projects (if supported).
- `workflow_step_uids` (`array`, optional): Optional array of workflow step UIDs to filter workflows that contain these steps.
- `workflow_uids` (`array`, optional): Optional array of specific workflow UIDs to retrieve. Use this when you need to get specific workflows by their unique identifiers.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_machine_translate_file`

SmartlingMachineTranslateFile · Read-only

Translates file content using machine translation.

# Use cases
- User requests to translate files (text or binary).

Two ways to supply the file - provide exactly one of `upload_id` or `file_content`:
1. `upload_id` (preferred, default choice): call smartling_request_upload_url first, PUT the file to the returned URL, then pass the returned upload_id here. Use this whenever you can run shell commands (e.g. Claude Code, Codex CLI, opencode, Cursor, Cline, Windsurf), regardless of file size or type - do not fall back to file_content just because the file is small.
2. `file_content` (inline base64): only use this when you cannot run shell commands (e.g. claude.ai) or the user explicitly asks for inline/base64 content.

Auto-detects source language if `source_locale` not provided.
Must ask user for `target_locale` if not specified.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `file_name` (`string`, required): Original filename for context.
- `mime_type` (`string`, required): MIME type of the file.
- `target_locale` (`string`, required): Target language locale code (2 or 5 letters, e.g., "en" or "en-US", dash separator only). Must ask user if not provided.
- `file_content` (`string`, optional): File content encoded as base64 string. Exactly one of file_content or upload_id must be provided. Use upload_id instead whenever you can run shell commands (e.g. Claude Code, Codex CLI, opencode, Cursor, Cline, Windsurf) - only use file_content when you cannot, or the user explicitly asks for inline/base64 content.
- `source_locale` (`string`, optional): Source language locale code (2 or 5 letters, e.g., "it" or "it-IT", dash separator only). Auto-detected if omitted.
- `upload_id` (`string`, optional): Identifier returned by a prior smartling_request_upload_url call. Exactly one of file_content or upload_id must be provided. Preferred over file_content whenever you can run shell commands (e.g. Claude Code, Codex CLI, opencode, Cursor, Cline, Windsurf) - call smartling_request_upload_url first, PUT the file, then pass the returned upload_id here, regardless of file size.

Example input: `{"account_id":"<account_id>","file_name":"<file_name>","mime_type":"<mime_type>","target_locale":"en"}`

### `smartlingmcp_smartling_machine_translate_text`

SmartlingMachineTranslateText · Read-only

Translates text content using machine translation.

# Use cases
- User requests to translate text or simple text files (txt format).

For file translation, read the file contents first.
Split long text into sentence-based chunks to preserve meaning and context - avoid breaking mid-sentence or splitting related content.
Each chunk becomes an object `{ "key": "<unique_key>", "source_text": "<text_to_translate>" }` with `key` (unique identifier) and `source_text` (content to translate) in the `text_items_to_translate` array.
Total request size must not exceed 10MB.
Auto-detects source language if `source_locale` not provided.
Must ask user for `target_locale` if not specified.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `target_locale` (`string`, required): Target language locale code (2 or 5 letters, e.g., "en" or "en-US", dash separator only). Must ask user if not provided.
- `text_items_to_translate` (`array`, required): Array of text items to be translated. Each item should have a unique key and the text to be translated.
- `source_locale` (`string`, optional): Source language locale code (2 or 5 letters, e.g., "it" or "it-IT", dash separator only). Auto-detected if omitted.

Example input: `{"account_id":"<account_id>","target_locale":"en","text_items_to_translate":[]}`

### `smartlingmcp_smartling_match_glossary_terms`

SmartlingMatchGlossaryTerms · Read-only

Match terms within a specific glossary.

# Use cases
- User requests to find specific terms in a source and translated strings.
- User requests to find specific terms in a source only strings.

# Examples
- Match glossary terms in source and translated strings:
{
    "glossary_uids": ["glossary-uid-1"],
    "source_locale_id": "en-US",
    "translation_locale_id": "fr-FR",
    "source_text_to_match": [
        {
            "key": "text-1",
            "text": "Hello"
        },
        {
            "key": "text-2",
            "text": "World"
        }
    ],
    "translation_text_to_match": [
        {
            "key": "text-1",
            "text": "Bonjour"
        },
        {
            "key": "text-2",
            "text": "Monde"
        }
    ]
}
- Match glossary terms in source only strings (pass only source strings but leave translation strings empty and preserve keys):
{
    "glossary_uids": ["glossary-uid-1"],
    "source_locale_id": "en-US",
    "translation_locale_id": "fr-FR",
    "source_text_to_match": [
        {
            "key": "text-1",
            "text": "Hello"
        },
        {
            "key": "text-2",
            "text": "World"
        }
    ],
    "translation_text_to_match": [
        {
            "key": "text-1",
            "text": ""
        },
        {
            "key": "text-2",
            "text": ""
        }
    ]
}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.
- `glossary_uids` (`array`, required): Array of glossary UIDs to search within.
- `source_locale_id` (`string`, required): Source locale ID for the terms to match.
- `source_text_to_match` (`array`, required): Source text to match against glossary terms.
- `translation_locale_id` (`string`, required): Target locale ID for the terms to match.
- `translation_text_to_match` (`array`, required): Translation text to match against glossary terms. If you need to only find terms in source string then set source_text_to_match and leave translation_text_to_match[N].text empty (you still need to pass translation_text_to_match[N].key).
- `mt_optimized_terms_only` (`boolean`, optional): Whether to include only MT-optimized terms. If not specified then MT-optimized only terms will be included.

Example input: `{"account_id":"<account_id>","glossary_uids":[],"source_locale_id":"en","source_text_to_match":[],"translation_locale_id":"<translation_locale_id>","translation_text_to_match":[]}`

### `smartlingmcp_smartling_search_strings`

SmartlingSearchStrings · Read-only

Search for strings in a Smartling project using various filters.

# What is string searching?
String searching allows you to find translation strings within a Smartling project based on various criteria like status, content, target locales, and more. This helps manage and locate specific strings for translation workflows.

# Use cases
- User requests to find strings by status (e.g., "untranslated", "translated", "approved")
- User wants to search strings by source content keywords
- User needs to find strings for specific target locales
- User wants to discover strings in a project for review or analysis
- User needs to find strings matching specific criteria for translation management

# Examples
- Search all untranslated strings in a project: Use project_uid and status parameters
- Find strings containing specific text: Use project_uid and source_keyword parameters
- Search strings for specific locales: Use project_uid and locale_ids parameters
- General string discovery: Use project_uid parameter only for all strings (up to 100 results)

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `project_uid` (`string`, required): The unique identifier of the Smartling project to search strings within (e.g., "project-uid-123", "abc123def456")
- `active_strings_filter` (`object`, optional): Filter by active string presence.
- `assignment_filter` (`object`, optional): Filter by user assignment
- `context_filter` (`object`, optional): Filter by context presence with optional URL/UID filtering
- `estimated_edit_effort_filter` (`object`, optional): Filter by estimated edit effort levels.
- `hashcodes` (`array`, optional): Array of specific string hashcodes to search for (unique string identifiers)
- `history_filter` (`object`, optional): Filter by history actions and time intervals.
- `ingestion_warning_type_filter` (`object`, optional): Filter by ingestion warning types like CHARACTER_TO_WORD_RATIO_HIGH, STRING_TOO_LONG, etc.
- `instructions_filter` (`object`, optional): Filter by presence and content of translation instructions
- `issues_filter` (`object`, optional): Filter by string issues.
- `key_variant_filter` (`object`, optional): Filter by string key keyword with exact match option
- `locale_ids` (`array`, optional): Array of target locale identifiers to filter strings (e.g., ["es-ES", "fr-FR", "de-DE"])
- `namespace_filter` (`object`, optional): Filter by specific namespace name
- `placeholder_plurals_selector` (`string`, optional): Control display of placeholder and plural forms. Available options: HAS_PLACEHOLDERS, HAS_PLURALS, HAS_BOTH. One of: `HAS_PLACEHOLDERS`, `HAS_PLURALS`, `HAS_BOTH`.
- `prepublish_filter` (`object`, optional): Filter by prepublish presence
- `source_keyword` (`string`, optional): Text to search for within source string content (partial text matching)
- `source_only` (`boolean`, optional): Whether to return only source strings without translation data
- `status` (`string`, optional): Filter strings by translation status. AWAITING_AUTH: awaiting authorization, IN_PROGRESS: translation in progress, PUBLISHED: completed and published, EXCLUDED: excluded from translation. One of: `AWAITING_AUTH`, `IN_PROGRESS`, `PUBLISHED`, `EXCLUDED`.
- `tags_filter` (`object`, optional): Filter by string tags.
- `translation_jobs_filter` (`object`, optional): Filter by translation job association
- `translation_review_filter` (`object`, optional): Filter by translation review presence and optional review state codes
- `translations_filter` (`object`, optional): Filter by translation presence and optionally search within translation text.
- `urls_filter` (`object`, optional): Filter by URL with exact match option
- `workflow_steps_filter` (`object`, optional): Filter by specific workflow step UIDs

Example input: `{"project_uid":"project-uid-123"}`

### `smartlingmcp_smartling_search_translation_memory`

SmartlingSearchTranslationMemory · Read-only

Search translation memory for similar translations in a Smartling project.

# What is translation memory?
A Translation Memory is a cloud-based database of all translations that have occurred within your Smartling account, as well as any translations that you may have imported to Smartling.
Translation Memories are used to leverage (or read from) previously used translations with new source content - allowing for cost savings, time savings, and translation consistency.
As translations are saved, they write to a designated Translation Memory.

# Use cases
- Useful for finding existing translations that match or are similar to source text.

# Examples
- Search for translations of "Hello world" in French:
{
    "project_id": "project-uid-123",
    "locale_id": "fr-FR",
    "search": "Hello world",
    "minimum_score": 0.7
}

- Find exact matches for UI text:
{
    "project_id": "project-uid-123",
    "locale_id": "es-ES",
    "search": "Click here to continue",
    "minimum_score": 0.95
}

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `locale_id` (`string`, required): The target locale identifier (e.g., "es-ES", "fr-FR") to search translations for. Must ask user if not provided.
- `project_id` (`string`, required): The unique identifier of the Smartling project to search translation memory within. Must ask user if not provided.
- `search` (`string`, required): The source text to search for in translation memory. This is the text you want to find similar translations for.
- `minimum_score` (`number`, optional): Minimum similarity score threshold (0.0 to 1.0). Higher values return more exact matches. For example, 0.5 means 50% similarity minimum. Defaults to 0.1 if not specified. Default: `0.1`.

Example input: `{"locale_id":"es-ES","project_id":"project-123","search":"<search>"}`

### `smartlingmcp_smartling_add_issue_comment`

SmartlingAddIssueComment · Write

Post a new comment on an issue.

# Use cases
- Reply to a translator question
- Add additional context to a flagged issue

# Examples
- project_id="p1", issue_uid="i1", comment_text="Use the formal 'vous' form here"

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `comment_text` (`string`, required): Comment body text (1–4000 chars)
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"comment_text":"<comment_text>","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_add_tags_to_strings`

SmartlingAddTagsToStrings · Write

Add tags to strings in a Smartling project.

# Use cases
- Categorize subsets of your content in a Project for quick and easy filtering

# Examples
- Add tags to mark strings for a specific release: tags=["v2.1", "new-feature"]
- Tag strings by component: tags=["navigation", "header"]
- Mark strings for review: tags=["needs-review", "high-priority"]

# Parameters
- project_id: The unique identifier of the Smartling project
- tags: Array of tag strings to add (max 100 tags, each max 128 characters)
- string_hashcodes: Array of string hashcodes to tag (max 1000 hashcodes)

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `string_hashcodes` (`array`, required): Array of string hashcodes to add tags to. Maximum 1000 string hashcodes can be processed at once.
- `tags` (`array`, required): Array of tag strings to add to the strings. Each tag must be 128 characters or less, and maximum 100 tags can be added at once.

Example input: `{"project_id":"project-123","string_hashcodes":[],"tags":[]}`

### `smartlingmcp_smartling_create_issue`

SmartlingCreateIssue · Write

Create a new string issue (question, clarification, quality flag) on a Smartling string.

# Use cases
- Translator flags an ambiguous source string with a CLARIFICATION sub-type
- QA raises a POOR_TRANSLATION issue against a translation
- PM creates a CUSTOM source issue with a HIGH severity assignment

# Examples
- Minimal: project_id, issue_text, issue_type=TRANSLATION, issue_sub_type=CLARIFICATION, string={hashcode, locale_id}
- With assignee + severity: also pass assignee_user_uid and issue_severity_level=HIGH

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `issue_sub_type` (`string`, required): Issue sub-type (CLARIFICATION, MISSPELLING, POOR_TRANSLATION, DOES_NOT_FIT_SPACE, PLACEHOLDER_ISSUE, REVIEW_TRANSLATION, CUSTOM, MT_ERROR). One of: `CLARIFICATION`, `MISSPELLING`, `POOR_TRANSLATION`, `DOES_NOT_FIT_SPACE`, `PLACEHOLDER_ISSUE`, `REVIEW_TRANSLATION`, `CUSTOM`, `MT_ERROR`.
- `issue_text` (`string`, required): Issue body text (1–4000 chars)
- `issue_type` (`string`, required): Issue type: SOURCE or TRANSLATION. One of: `SOURCE`, `TRANSLATION`.
- `project_id` (`string`, required): The Smartling project UID
- `string` (`object`, required): The string this issue is attached to
- `assignee_user_uid` (`string`, optional): Optional: user UID to assign the issue to (max 12 chars)
- `issue_severity_level` (`string`, optional): Optional: severity (LOW, MEDIUM, HIGH). One of: `LOW`, `MEDIUM`, `HIGH`.

Example input: `{"issue_sub_type":"CLARIFICATION","issue_text":"<issue_text>","issue_type":"SOURCE","project_id":"project-123","string":{}}`

### `smartlingmcp_smartling_create_job`

SmartlingCreateJob · Write

Create Smartling job.

# Use cases
- User needs to create jobs with specific parameters

# Job Details Response
The response includes detailed job information:
- Callback method and URL configuration
- Creation and modification user details
- Custom field values
- Complete job metadata and timestamps

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `job_name` (`string`, required): Name of the job
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `target_locale_ids` (`array`, required): Array of target locale IDs for translation
- `callback_method` (`string`, optional): Callback method configuration (GET, POST, etc.). One of: `GET`, `POST`.
- `callback_url` (`string`, optional): Callback URL for job notifications
- `custom_fields` (`array`, optional): Array of custom field values for the job
- `description` (`string`, optional): Job description
- `due_date` (`string`, optional): Due date for job completion
- `reference_number` (`string`, optional): Reference number for the job

Example input: `{"job_name":"<job_name>","project_id":"project-123","target_locale_ids":["es","fr","de"]}`

### `smartlingmcp_smartling_request_upload_url`

SmartlingRequestUploadUrl · Write

Requests a short-lived URL for uploading a local file, for use with other tools that accept an "upload_id" parameter (e.g. smartling_machine_translate_file).

# Use cases
- Preferred, default first step before translating or otherwise processing any local file, whenever you can run shell commands (e.g. Claude Code, Codex CLI, opencode, Cursor, Cline, Windsurf) - use this instead of inline base64 content regardless of file size or type.

Only usable by clients that can run shell commands (e.g. Claude Code, Codex CLI, opencode, Cursor, Cline, Windsurf) to PUT the file to the returned URL - not usable from claude.ai or other clients without local file/shell access, which should keep using inline base64 content instead.
The returned URL expires in 15 minutes. Upload immediately after requesting it, then pass the returned upload_id to the tool that needs the file.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `account_id` (`string`, required): Account UID. Call smartling_get_available_accounts_for_current_user first to retrieve it.

Example input: `{"account_id":"<account_id>"}`

### `smartlingmcp_smartling_add_strings_to_job`

SmartlingAddStringsToJob · Destructive

Add strings to an existing Smartling job by their hashcodes.

# What are string hashcodes?
String hashcodes are unique identifiers for translatable strings in Smartling. Each string in your project has a unique hashcode that can be used to reference it in various operations.

# Use cases
- User wants to add specific strings to a translation job
- User needs to include additional content in an existing job
- User wants to move strings from one job to another (when move_enabled=true)
- User needs to add strings for specific target locales only

# Examples
- Add strings to job: Provide project_id, job_uid, and array of hashcodes
- Add with specific locales: Include target_locale_ids to add strings for specific languages only
- Move strings between jobs: Set move_enabled=true to move strings from other jobs

# Parameters
- hashcodes: Array of string hashcodes to add to the job
- target_locale_ids: (Optional) Specific target locales to add strings for
- move_enabled: (Optional) Whether to move strings from other jobs if they exist elsewhere

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `hashcodes` (`array`, required): Array of string hashcodes to add to the job. Each hashcode uniquely identifies a translatable string.
- `job_uid` (`string`, required): The unique identifier of the job to add strings to (e.g., "job-uid-123", "translation-job-456")
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `move_enabled` (`boolean`, optional): (Optional) Whether to move strings from other jobs if they already exist elsewhere. Default is false.
- `target_locale_ids` (`array`, optional): (Optional) Array of target locale IDs to add strings for. If not provided, strings will be added for all job target locales. Example: ["es", "fr", "de"]

Example input: `{"hashcodes":[],"job_uid":"job-uid-123","project_id":"project-123"}`

### `smartlingmcp_smartling_authorize_job`

SmartlingAuthorizeJob · Destructive

Authorize a Smartling job to begin translation work with optional locale workflow assignments.

# What does job authorization mean?
Job authorization moves a job from "AWAITING_AUTHORIZATION" status to "IN_PROGRESS" status, allowing translators to begin working on the content. This is a critical step in the translation workflow.

# Use cases
- User has prepared a job with all necessary strings and is ready to begin translation
- User wants to start the translation process for a completed job setup
- User needs to move a job from draft/preparation phase to active translation
- User wants to trigger translator notifications and workflow assignment
- User needs to assign specific workflows to target locales during authorization

# Examples
- Basic authorization: Provide project_id and job_uid to authorize the job
- Authorization with locale workflows: Include locale_workflows to assign specific workflows to target locales
- Start translation work: Once authorized, the job becomes available to translators
- Workflow activation: Authorization triggers any configured workflow assignments

# Locale Workflows
- Optional parameter to assign specific workflows to target locales
- Each entry maps a target locale to a specific workflow UID
- Format: [{"target_locale_id": "es-ES", "workflow_uid": "workflow-123"}]
- Useful for assigning different translation workflows to different languages

# Important Notes
- Jobs must be in "AWAITING_AUTHORIZATION" status to be authorized
- Once authorized, jobs typically cannot be moved back to unauthorized status
- Authorization may trigger notifications to assigned translators or project managers
- Locale workflows are optional and will use project defaults if not specified

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `job_uid` (`string`, required): The unique identifier of the job to authorize (e.g., "job-uid-123", "translation-job-456")
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `locale_workflows` (`array`, optional): (Optional) Array of locale-workflow mappings to assign specific workflows to target locales during authorization. Example: [{"target_locale_id": "es-ES", "workflow_uid": "workflow-123"}]

Example input: `{"job_uid":"job-uid-123","project_id":"project-123"}`

### `smartlingmcp_smartling_create_strings`

SmartlingCreateStrings · Destructive

Create strings in a Smartling project and poll until completion.

# What are strings in Smartling?
Strings are individual pieces of text content that need to be translated. Each string has a unique identifier (hashcode) and can contain metadata like instructions, format specifications, and variant information.

# Use cases
- Create new translatable content in a Smartling project
- Upload strings with specific formatting requirements
- Add strings with translation instructions and context
- Bulk create strings for translation workflows

# Examples
- Create simple strings: strings=[{"string_text": "Hello World"}]
- Create strings with variants: strings=[{"string_text": "Submit", "variant": "button.submit"}]
- Create strings with instructions: strings=[{"string_text": "Click here", "instruction": "This is a call-to-action button"}]
- Create strings with formatting: strings=[{"string_text": "<b>Bold text</b>", "format": "html"}]

# Parameters
- project_id: The unique identifier of the Smartling project
- namespace: (Optional) Namespace to organize strings
- placeholder_format: (Optional) Format for placeholders (e.g., "java", "python", "c", "resx", "yaml")
- placeholder_format_custom: (Optional) Custom regex pattern for placeholders
- strings: Array of string objects to create (max 100 strings per request)

# String Object Properties
- string_text: The actual text content (required)
- variant: (Optional) Unique identifier/key for the string
- callback_url: (Optional) URL for callback notifications
- callback_method: (Optional) HTTP method for callback (GET, POST)
- instruction: (Optional) Translation instruction/context
- format: (Optional) Content format (plain, html, xml, etc.)
- max_length: (Optional) Maximum character length for translations

# Polling Behavior
This tool automatically polls the creation process status until completion (up to 5 minutes).
It returns when the process is either successfully completed or failed.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `strings` (`array`, required): Array of string objects to create. Maximum 100 strings can be created in a single request
- `namespace` (`string`, optional): (Optional) Namespace to organize and group related strings (e.g., "app.navigation", "forms.validation")
- `placeholder_format` (`string`, optional): (Optional) Predefined placeholder format. Common values: "java" ({name}), "python" (%(name)s), "c" (%s), "resx" ({0}), "yaml" (%{name})
- `placeholder_format_custom` (`string`, optional): (Optional) Custom regular expression pattern for identifying placeholders in the string text

Example input: `{"project_id":"project-123","strings":[]}`

### `smartlingmcp_smartling_delete_issue_assignee`

SmartlingDeleteIssueAssignee · Destructive

Unassign the user currently assigned to an issue.

# Use cases
- Remove the current assignee when the issue should not be owned by anyone

# Examples
- project_id="p1", issue_uid="i1"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_delete_issue_comment`

SmartlingDeleteIssueComment · Destructive

Delete a comment from an issue.

# Use cases
- Remove an off-topic or incorrect comment

# Examples
- project_id="p1", issue_uid="i1", issue_comment_uid="c1"

# Important
This action cannot be easily undone.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `issue_comment_uid` (`string`, required): The comment UID to delete
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_comment_uid":"<issue_comment_uid>","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_edit_issue_text`

SmartlingEditIssueText · Destructive

Edit the body text of an existing issue.

# Use cases
- Fix a typo in an issue's text
- Clarify a previously-vague issue description

# Examples
- project_id="abc", issue_uid="i1", issue_text="Updated description"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `issue_text` (`string`, required): New issue body text (1–4000 chars)
- `issue_uid` (`string`, required): The issue UID to edit
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_text":"<issue_text>","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_open_or_close_issue`

SmartlingOpenOrCloseIssue · Destructive

Open or close (resolve) an issue.

# Use cases
- Resolve an issue once the underlying string question is answered
- Re-open a resolved issue that needs more discussion

# Examples
- Resolve: project_id="p1", issue_uid="i1", issue_state="RESOLVED"
- Re-open: issue_state="OPENED"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `issue_state` (`string`, required): New state: OPENED or RESOLVED. One of: `OPENED`, `RESOLVED`.
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_state":"OPENED","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_remove_all_tags_from_strings`

SmartlingRemoveAllTagsFromStrings · Destructive

Remove all tags from strings in a Smartling project.

# Use cases
- Clean slate for string reorganization - remove all tags before applying new categorization
- Prepare strings for migration to a different tagging system
- Batch clean up of strings during project restructuring

# Examples
- Clean up strings before project migration
- Remove all tags from deprecated feature strings  
- Reset tagging for strings that will be recategorized
- Clean up test strings that accumulated development tags

# Parameters
- project_id: The unique identifier of the Smartling project
- string_hashcodes: Array of string hashcodes to remove all tags from (max 1000 hashcodes)

# Important Note
This operation removes ALL tags from the specified strings. Use with caution as this action cannot be easily undone.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `string_hashcodes` (`array`, required): Array of string hashcodes to remove all tags from. Maximum 1000 string hashcodes can be processed at once.

Example input: `{"project_id":"project-123","string_hashcodes":[]}`

### `smartlingmcp_smartling_remove_strings_from_job`

SmartlingRemoveStringsFromJob · Destructive

Remove strings from an existing Smartling job by their hashcodes.

# Use cases
- User wants to remove specific strings from a translation job
- User needs to exclude certain content from an existing job
- User wants to remove strings for specific target locales only
- User needs to clean up job content before authorization

# Examples
- Remove strings from job: Provide project_id, job_uid, and array of hashcodes
- Remove for specific locales: Include target_locale_ids to remove strings for specific languages only
- Clean up job: Remove unnecessary strings before job authorization

# Parameters
- hashcodes: Array of string hashcodes to remove from the job
- target_locale_ids: (Optional) Specific target locales to remove strings for

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `hashcodes` (`array`, required): Array of string hashcodes to remove from the job. Each hashcode uniquely identifies a translatable string.
- `job_uid` (`string`, required): The unique identifier of the job to remove strings from (e.g., "job-uid-123", "translation-job-456")
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `target_locale_ids` (`array`, optional): (Optional) Array of target locale IDs to remove strings for. If not provided, strings will be removed for all job target locales. Example: ["es", "fr", "de"]

Example input: `{"hashcodes":[],"job_uid":"job-uid-123","project_id":"project-123"}`

### `smartlingmcp_smartling_remove_tags_from_strings`

SmartlingRemoveTagsFromStrings · Destructive

Remove tags from strings in a Smartling project.

# Use cases
- Remove outdated tags from strings

# Examples
- Clean up categorization tags: tags=["old-feature", "deprecated"]
- Remove release tags after deployment: tags=["v2.0", "pending-release"]

# Parameters
- project_id: The unique identifier of the Smartling project
- tags: Array of tag strings to remove (max 100 tags, each max 128 characters)
- string_hashcodes: Array of string hashcodes to remove tags from (max 1000 hashcodes)

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `string_hashcodes` (`array`, required): Array of string hashcodes to remove tags from. Maximum 1000 string hashcodes can be processed at once.
- `tags` (`array`, required): Array of tag strings to remove from the strings. Each tag must be 128 characters or less, and maximum 100 tags can be removed at once.

Example input: `{"project_id":"project-123","string_hashcodes":[],"tags":[]}`

### `smartlingmcp_smartling_update_issue_answered`

SmartlingUpdateIssueAnswered · Destructive

Mark an issue as answered or un-answered.

# Use cases
- Mark an issue answered after a reply is posted
- Clear the answered flag if the reply is later found inadequate

# Examples
- project_id="p1", issue_uid="i1", answered=true

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `answered` (`boolean`, required): New answered state
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"answered":true,"issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_update_issue_assignee`

SmartlingUpdateIssueAssignee · Destructive

Assign an issue to a specific user.

# Use cases
- Route an issue to the responsible PM or translator for action

# Examples
- project_id="p1", issue_uid="i1", assignee_user_uid="user-xyz"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `assignee_user_uid` (`string`, required): User UID to assign the issue to (max 12 chars)
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"assignee_user_uid":"<assignee_user_uid>","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_update_issue_comment`

SmartlingUpdateIssueComment · Destructive

Edit the text of an existing comment.

# Use cases
- Fix a typo in a comment
- Update outdated guidance in a comment

# Examples
- project_id="p1", issue_uid="i1", issue_comment_uid="c1", comment_text="Edited"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `comment_text` (`string`, required): New comment body text (1–4000 chars)
- `issue_comment_uid` (`string`, required): The comment UID
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"comment_text":"<comment_text>","issue_comment_uid":"<issue_comment_uid>","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_update_issue_severity_level`

SmartlingUpdateIssueSeverityLevel · Destructive

Change the severity level of an issue.

# Use cases
- Escalate an issue from MEDIUM to HIGH
- Downgrade severity once mitigated

# Examples
- project_id="p1", issue_uid="i1", issue_severity_level="HIGH"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `issue_severity_level` (`string`, required): New severity: LOW, MEDIUM, or HIGH. One of: `LOW`, `MEDIUM`, `HIGH`.
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID

Example input: `{"issue_severity_level":"LOW","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_update_issue_type`

SmartlingUpdateIssueType · Destructive

Change the type and sub-type of an issue (optionally narrowing to one locale).

# Use cases
- Re-categorize a CLARIFICATION issue as MISSPELLING after triage
- Move a TRANSLATION issue to a specific locale

# Examples
- project_id="p1", issue_uid="i1", issue_type="TRANSLATION", issue_sub_type="MISSPELLING"
- with locale: also locale_id="fr-FR"

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `issue_sub_type` (`string`, required): New sub-type. One of: `CLARIFICATION`, `MISSPELLING`, `POOR_TRANSLATION`, `DOES_NOT_FIT_SPACE`, `PLACEHOLDER_ISSUE`, `REVIEW_TRANSLATION`, `CUSTOM`, `MT_ERROR`.
- `issue_type` (`string`, required): New type: SOURCE or TRANSLATION. One of: `SOURCE`, `TRANSLATION`.
- `issue_uid` (`string`, required): The issue UID
- `project_id` (`string`, required): The Smartling project UID
- `locale_id` (`string`, optional): Optional: narrow the issue to this target locale (max 5 chars)

Example input: `{"issue_sub_type":"CLARIFICATION","issue_type":"SOURCE","issue_uid":"<issue_uid>","project_id":"project-123"}`

### `smartlingmcp_smartling_update_job`

SmartlingUpdateJob · Destructive

Get detailed information about a specific Smartling job by its UID.

# Use cases
- User wants to set any of optional job properties like due date
- User needs to edit job metadata

# Job Details Response
The response includes detailed job information:
- Callback method and URL configuration
- Creation and modification user details
- Custom field values
- Complete job metadata and timestamps

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `job_name` (`string`, required): Name of the job
- `job_uid` (`string`, required): Unique identifier for the translation job
- `project_id` (`string`, required): The unique identifier of the Smartling project (e.g., "project-123", "abc123def456")
- `callback_method` (`string`, optional): Callback method configuration (GET, POST, etc.). One of: `GET`, `POST`.
- `callback_url` (`string`, optional): Callback URL for job notifications
- `custom_fields` (`array`, optional): Array of custom field values for the job
- `description` (`string`, optional): Job description
- `due_date` (`string`, optional): Due date for job completion
- `reference_number` (`string`, optional): Reference number for the job

Example input: `{"job_name":"<job_name>","job_uid":"job-uid-123","project_id":"project-123"}`

## Related

Other AI connectors ([all 116](/agentkit/connectors/?category=ai)):

- [Chorus](/agentkit/connectors/chorus/): Scalekit connector, Username and password, 9 tools
- [Gong](/agentkit/connectors/gong/): Scalekit connector, OAuth, 49 tools
- [Jiminny](/agentkit/connectors/jiminny/): Scalekit connector, Access token, 27 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |