How AI agents can search and filter localization resources using Crowdin skills

If you have ever managed a localization project with tens of thousands of strings, you know the struggle: finding duplicate keys, locating untranslated strings with specific tags, or fetching clean Translation Memory (TM) segments manually takes hours.

While Crowdin provides powerful querying tools like CroQL (Crowdin Query Language) and GraphQL, crafting precise query expressions isn’t always intuitive.

What if you could ask an AI coding assistant (like Claude Desktop, Cursor, or GitHub Copilot) to do that for you?

In our previous guide on automating i18n context with AI agents, we covered how AI can automatically generate context descriptions for translators. But AI agents can do much more than just enrich JSON files.

By combining AI Agents with Crowdin’s open-source croql and graphql agentic skills, you can also turn natural language questions into valid, optimized Crowdin API queries in seconds. Here is how to set it up and leverage it in your automated localization workflows.

Why pair AI Agents with CroQL and GraphQL?

• No syntax friction - you don’t need to memorize exact CroQL operators or navigate GraphQL schema structures.
• Safe and optimized - AI equipped with Crowdin skills knows context-specific limitations – preventing invalid field filters, handling URL encoding automatically, and applying rate-limit safeguards.
• Automation - easily feed generated queries directly into your Node.js scripts, GitHub Actions, or API clients.

How to load Crowdin skills into your AI workspace

Before diving into the scenarios, you need to equip your AI assistant with the necessary rules and schemas. Instead of downloading or copying files manually, you can quickly install Crowdin Skills using the CLI or native plugin integrations:

1. Via CLI (npx skills)

Run the skills installer in your terminal to easily add croql, graphql, or any other skill to your workspace:

npx skills add crowdin/skills

2. Via IDE and agent plugins

If you are using Cursor, Claude Desktop, or custom MCP agents, you can install the Crowdin plugin directly through your editor’s marketplace or extension manager.

Once installed, your AI assistant instantly understands Crowdin’s querying syntax, field constraints, and API safety rules, without any manual setup or maintenance.

Scenario 1: Quick search with CroQL and AI

CroQL is designed for filtering strings, translations, TM segments, and glossaries inside Crowdin. However, subtle syntax errors (like using string filters on TM segments) can break API calls.

Task: you want to clean up your project by finding all untranslated strings added after a specific date that contain the tag onboarding_v2.

AI prompt

"Write a CroQL expression to find all untranslated strings with the tag 'onboarding_v2' created after January 1, 2026. Make sure it's safely URL-encoded for the Crowdin API endpoint."

What AI generates (using the croql skill)

AI checks the schema rules, builds the query, and handles URL encoding:

Raw CroQL expression:

has tags "onboarding_v2" and count of translations = 0 and createdAt > "2026-01-01"

API-ready endpoint URL:

GET https://api.crowdin.com/api/v2/projects/{projectId}/strings?croql=has%20tags%20%22onboarding_v2%22%20and%20count%20of%20translations%20%3D%200%20and%20createdAt%20%3E%20%222026-01-01%22

Scenario 2: Deep inspection with GraphQL

When REST API calls require too many roundtrips, Crowdin’s GraphQL API lets you fetch nested data in a single request, such as a string along with its translations, approval status, and author details.

Task: you need to inspect unapproved translations for a specific feature branch without making dozens of individual REST calls.

AI prompt

"Write a Crowdin GraphQL query to fetch strings on branch 'feature-checkout', including their string ID, text, and any unapproved translations along with the translator's username. Include pagination safeguards."

What AI generates (using the graphql skill)

AI generates a schema-aware query with first and after arguments to prevent rate-limit hits:

query GetUnapprovedCheckoutTranslations($projectId: ID!, $cursor: String) {
  project(id: $projectId) {
    sourceStrings(first: 50, after: $cursor, filter: { branch: "feature-checkout" }) {
      pageInfo {
        hasNextPage
        endCursor
      }
      edges {
        node {
          id
          text
          translations(filter: { isApproved: false }) {
            id
            text
            user {
              username
            }
          }
        }
      }
    }
  }
}

Other use cases you can automate with this skills

Here are a few practical scenarios where combining these AI skills with CroQL and GraphQL saves hours of tedious work:

• Clean up legacy string files. Ask your AI with the croql skill to isolate unused strings, keys missing context descriptions, or duplicates across multiple files before starting a new vendor contract.
• Build custom QA dashboard metrics. Let AI use graphql skill to construct precise queries for internal progress dashboards (like tracking unapproved vs. approved translations) without hitting REST API rate limits.
• Targeted translation memory cleanup. Have your AI draft complex CroQL queries to target outdated TM segments matching specific regex patterns or older target languages that need re-alignment.
• Automated pull request validation. Prompt AI to generate CroQL filters for your CI/CD pipelines (e.g., GitHub Actions) to block builds if high-priority UI keys lack required translations.
• Feature branch progress tracking. Use the graphql skill to let AI fetch translation progress and approval status for specific feature branches in a single lightweight payload instead of dozens of REST calls.
• Catching broken variables and syntax errors. Prompt your AI assistant to generate CroQL regex expressions that instantly spot hardcoded HTML, mismatched placeholders (for example, {userName} vs %username%), or illegal characters.
• Legal and compliance audits. Ask AI to generate a full-text CroQL sweep across source strings and translations to locate outdated company names, old policy dates, or legacy legal terms.
• Smart glossary audits. Let the AI apply croql skill to filter glossary terms by tags, creation dates, or missing target languages so it can audit and maintain terminology automatically.

With these skills in your AI assistant’s arsenal, virtually any repetitive data-filtering, audit, or querying task in Crowdin can be automated using plain English.

Ready to automate your Crowdin queries?

Go to the Crowdin Skills Repository on GitHub, install croql and graphql skills, and start prompting your AI assistant directly in your IDE today.

FAQ

1. What are Crowdin Skills, and how do they work?

Crowdin Agentic Skills are open-source context configurations (like Cursor rules or system prompts) designed for AI assistants and LLMs. They teach AI agents the specific schema, syntax, operators, and constraints of Crowdin tools—such as CroQL and GraphQL—enabling the AI to generate accurate, execution-ready code and API queries without hallucinations.

2. Do I need a paid Crowdin plan to use CroQL or GraphQL with AI Skills?

No. Both CroQL filtering and GraphQL API capabilities are built into Crowdin’s platform features and API. You only need standard API access credentials (a Personal Access Token) and an AI interface (such as Claude Desktop, Cursor, or custom OpenAI scripts) loaded with the relevant skills.

3. How do I add these skills to Cursor or Claude Desktop?

The recommended approach is to use the npx skills CLI command in your terminal (npx skills add crowdin/skills), which automatically fetches and configures the latest skill definitions for your workspace. Alternatively, you can search for and install the Crowdin plugin directly through your IDE’s extension/marketplace ecosystem.

4. Why use GraphQL instead of Crowdin’s standard REST API v2?

While the REST API is great for straightforward endpoints, GraphQL lets you retrieve deeply nested data (such as a string, its unapproved translations, and user metadata) in a single network request. This reduces latency and prevents rate-limiting issues when running complex AI automated tasks.

5. Can AI agents automatically execute these queries, or do they only generate them?

Both. If you are using AI agents with Model Context Protocol (MCP) or tool-calling capabilities, the AI can both generate the CroQL/GraphQL query and execute HTTP requests against the Crowdin API. If used in an IDE like Cursor, the AI typically generates the query or code snippet for you to review and integrate into your codebase.