# Developer Documentation
Here you can find all resources about our integrations or the API reference.
## Integrations
* WordPress : All hooks & filters in the WordPress plugin.
* Javascript : All functions you call when you are using the JS lib.
## Reference
You can find the [API reference](/api/reference) if you want to make HTTP Request directly.
## Slack
You can join our [**Weglot Community**](https://communityinviter.com/apps/weglot-community/weglot-community) Slack where we would be happy to get direct feedback and provide tips
# Requirements
## Requirements
Before installing Weglot, make sure your environment meets the minimum requirements. They depend on the plugin version you're running.
### Weglot 6.1 and later
| Requirement | Minimum | Tested up to |
| ------------------------ | ------- | ------------ |
| WordPress | 5.9 | 7.0 |
| PHP | 7.4 | — |
| WooCommerce *(optional)* | 4.0 | 9.5 |
### Weglot before 6.1
| Requirement | Minimum | Tested up to |
| ------------------------ | ------- | ------------ |
| WordPress | 4.5 | 6.9 |
| PHP | 7.4 | — |
| WooCommerce *(optional)* | 4.0 | 9.5 |
{% hint style="info" %}
WooCommerce is only required if you translate a WooCommerce store.
{% endhint %}
{% hint style="success" %}
**Next step:** once your environment is ready, follow the [Getting Started](/wordpress/getting-started) guide to install and configure the plugin.
{% endhint %}
# Getting Started
Starting with the Weglot WordPress plugin
## Getting Started
### Introduction
Weglot has built a powerful WordPress plugin that integrates in your WordPress website and make it multilingual in a few minutes.
What does Weglot plugin do exactly ?
1. It creates URL for each languages, like `/fr/about/` or `/es/about/` for instance (but doesn't create actual pages in WordPress backend)
2. On these URL, it returns the translated content
3. It adds a language button on the page and the `hreflang` tags in the `` section of your page for SEO.
### Getting started
To start, install [Weglot Translate](https://wordpress.org/plugins/weglot/) plugin directly from the directory.
In the settings page, configure the 3 mandatory settings :
* **API Key** : You get an API key in your account. If you don't have one, you can [create your account](https://dashboard.weglot.com/register-wordpress).
* **Original Language** : The original language of your WordPress website.
* **Destination Languages** : The languages you want your website to be translated into.
Save the settings and you are done. You will see the language button appear on your website.
{% hint style="success" %}
**Next step:** head over to [Plugin settings](/wordpress/plugin-settings) to control what gets translated (emails, search, specific URLs or blocks) and customize the language switcher.
{% endhint %}
# Plugin settings
## Plugin settings
Once the plugin is set up, a few built-in options let you fine-tune **what** gets translated and **how** the language switcher looks. You'll find them in the plugin's **Advanced** and **Appearance** tabs.
### Translate emails
When enabled, Weglot translates the emails sent by WordPress (through the `wp_mail` function) — both the **subject** and the **body** — into the language of the visitor who triggered them. Typical examples are a WooCommerce order confirmation or a contact-form notification sent to your customer.
The visitor's language is detected from the current request, or from the page they were on when the email was sent.
{% hint style="info" %}
Emails sent to your **site admin address are not translated** by default — they stay in your original language, which is usually what you want for internal notifications.
{% endhint %}
### Translate search
When enabled, your visitors can search your site in their own language. Weglot translates their search term back into your original language, runs the WordPress search on your original content, and returns the results translated.
This means you don't need to store translated content in your database for search to work.
### Exclude URLs
By default, every page of your site is translated. Use **Exclude URLs** to leave some pages untranslated. Rules are managed from your Weglot dashboard and support several matching modes:
* **Contains** — the path contains a given text (default)
* **Is exactly** — the path matches exactly
* **Starts with** / **Ends with**
* **Matches regex** — for advanced patterns
For example, to translate **only your homepage** (exclude every path except `/`), use a "Matches regex" rule with: `[^/]`
{% hint style="info" %}
Rules are matched against the URL **path** only — the query string (everything after `?`) is ignored.
{% endhint %}
### Exclude blocks
Sometimes you want to keep part of a page untranslated — a customer-review area, a code snippet, a brand name. With **Exclude blocks** you provide a CSS selector, and Weglot adds a `data-wg-notranslate` attribute to the matching element. Everything inside it is left as-is.
For example, excluding `.product-description` produces:
```markup
Mon super article
My awesome article
```
### Language switcher
Weglot adds a language button to your site. From the **Appearance** tab you can customize how it looks:
* **Dropdown or inline** — show the languages in a dropdown menu or side by side
* **With flags** — show a flag next to each language, and choose its shape: rectangle (mat or shiny), square or circle
* **With name** — show the language name, either its full local name (e.g. *Français*) or its ISO code (e.g. *FR*)
* **Custom CSS** — override the switcher's styling with your own rules
#### Positioning the switcher
You can place the language button wherever you want:
* **Default** — automatically added at the bottom-right of every page
* **In a menu** — add a "Weglot Translate" item from *Appearance → Menus*
* **In a widget area** — from *Appearance → Widgets*
* **Anywhere via shortcode** — drop `[weglot_switcher]` into a page, post or template
# Helpers Functions
All Weglot functions you can call in WordPress to get informations
## Helpers Functions
Weglot plugin is exposing functions that can be called in your code.
To see the source code of all available functions, you can go to the file : **weglot-functions.php.**
{% hint style="warning" %}
Make sure your plugin's version is > 3.0
{% endhint %}
#### weglot\_get\_service
```php
weglot_get_service( string $service )
```
Return a Weglot service.
#### weglot\_get\_options
```php
weglot_get_options()
```
Return all Weglot options.
#### weglot\_get\_option
```php
weglot_get_option( string $key )
```
Return Weglot option by key.
#### weglot\_get\_original\_language
```php
weglot_get_original_language()
```
Return the original language code (2-letter internal code, e.g. `en`).
#### weglot\_get\_current\_language
```php
weglot_get_current_language()
```
Return the current language **internal** code (2-letter code, e.g. `en`). This is the code Weglot uses internally, not the one that may appear in your URLs.
#### weglot\_get\_current\_language\_custom
```php
weglot_get_current_language_custom()
```
Return the current language **external** code — the custom language code configured in your Weglot dashboard (falls back to the standard code when none is set). Use this when you need the code as it appears to your visitors.
{% hint style="info" %}
`weglot_get_current_language_code_from_custom_language()` is an alias that returns the exact same value.
{% endhint %}
#### weglot\_get\_destination\_languages
```php
weglot_get_destination_languages()
```
Return an array of public destination language keys.
#### weglot\_get\_request\_url\_service
```php
weglot_get_request_url_service()
```
Return weglot request URL service.
#### weglot\_get\_languages\_available
```php
weglot_get_languages_available()
```
Return an array of all languages objects available.
#### weglot\_get\_button\_selector\_html
```php
weglot_get_button_selector_html( string $add_class = '' )
```
Return the language's selector button HTML in string format.
#### weglot\_get\_exclude\_urls
```php
weglot_get_exclude_urls()
```
Return an array of all excluded URLs.
#### weglot\_get\_translate\_amp\_translation
```php
weglot_get_translate_amp_translation()
```
Return `true` if amp pages translation is activated.
#### weglot\_get\_current\_full\_url
```php
weglot_get_current_full_url()
```
Return a string of current URL.
#### weglot\_create\_url\_object
```php
weglot_create_url_object( string $url )
```
Return a `Weglot\Util\Url` object for the given URL. Call `->getForLanguage( $language )` on it to get the URL translated into a specific language.
#### weglot\_is\_eligible\_url
```php
weglot_is_eligible_url( string $url )
```
Return `true` if `$url` is an eligible URL.
#### weglot\_get\_api\_key
```php
weglot_get_api_key()
```
Return a string of private API key.
#### weglot\_has\_auto\_redirect
```php
weglot_has_auto_redirect()
```
Return `true` if redirect users based on their browser language option is activated.
#### weglot\_get\_full\_url\_no\_language
```php
weglot_get_full_url_no_language()
```
Return a string of current URL without the language key.
#### weglot\_get\_postid\_from\_url
```php
weglot_get_postid_from_url()
```
Return the WordPress post ID matching the current URL, or `0` if none is found.
#### weglot\_get\_rest\_current\_url\_path
```php
weglot_get_rest_current_url_path()
```
Return a string of rest current URL path.
# Hooks
All filters exposed by Weglot
# Translations Hooks
WordPress Filters relating to detecting & translating words
Weglot plugin will detect all the words in your HTML. To do this, it will parse the DOM in PHP and detect the inner text of HTML nodes but also some attributes we have defined, like the "placeholder" attribute in a `` node or the "alt" attribute of an `img` node.
This usually ensure all the text in your page is detected and get translated. However, in some case, your text can be located in other location in your HTML. Like it could be in a JavaScript variable like this
```javascript
```
In that case, your text will not be detected and not be translated.
This is where you will use filters to extend the definitions of the Weglot Parser and instruct it to detect other text.
### Extend what gets detected
#### weglot\_get\_dom\_checkers
This filter extend the list of HTML nodes and attribute that are being translated.
| Argument | Type | Description |
| -------------- | ----- | --------------------------------------------------------------------------------- |
| $dom\_checkers | array | Names of used **DomChecker** (extends Weglot\Parser\Check\Dom\AbstractDomChecker) |
**Use case**
It can happen in your HTML that you use data-attributes that are not translated by default. Example with **data-slide-title**
```markup
New project !
```
With the `weglot_get_dom_checkers` filter, you will extend the list of "Dom checkers" by adding a class in the list like on the following example.
```php
jQuery(document).ready(function ($) {
// Untranslate text
alert("My untranslate text");
console.log("My untranslate text", "My untranslate text");
// Untranslate HTML
$("body").append("
My untranslate text
");
// Untranslate JSON values
var myJson = {
"MyKey1": {
"MyKey1-1": "My untranslate text",
"MyKey1-2": "My untranslate text"
},
"MyKey2": "My untranslate text",
"some_array" : [ "Hello" , "Translate this"]
};
});
This, no problem
```
In order for the content in this example to be interpreted, and then translated, we will use the **weglot\_get\_regex\_checkers** filter as followed.
```php
(.*)<\/script>#", "HTML", 1, array(),"json_decode" , "json_encode");
//More advanced : JSON after a callback
$regex_checkers[] = new \Weglot\Parser\Check\Regex\RegexChecker( '#data-escapedjson="((.|\s)+?)"#', 'JSON', 1, array(), "html_entity_decode" , "htmlentities" );
//More advanced : JSON after a callback, version with another regex
$regex_checkers[] = new \Weglot\Parser\Check\Regex\RegexChecker( '#data-escapedjson="(.*)"#', 'JSON', 1, array(), "html_entity_decode" , "htmlentities" );
return $regex_checkers;
}
```
#### weglot\_words\_translate
Use this filter to target a specific word literally in your source code.
| Argument | Type | Description |
| -------- | ----- | --------------- |
| $words | array | Array of string |
You can add words that are present in your HTML page but not translated. It's useful when a word is not being translated by Weglot because it's inside a JavaScript for example and you can't really use other filters.
**Use case**
```php
` tag and translates **only** the blocks matching the listed CSS selectors — everything else is left untranslated.
```php
HTML content, already translated", //Will be translated by default because we detect this is HTML
"message":"My message value to translate!" //This will not be translated and you will need to use the filter
}
```
To do this, we use **weglot\_add\_json\_keys** filter.
```php
` values whose content is escaped |
| `weglot_escape_script_ids` | `tmpl-*`, `nf-*`, `*-js-extra` | `
```php
add_action( 'wp_footer', 'weglotsupport_fix_avada_menu' );
function weglotsupport_fix_avada_menu() {
?>
is_eligible_url( weglot_get_current_full_url() );
if ( ! $show_button ) {
return '';
}
return $html;
}
```
# Auto switch only for HomePage
Since the version 3.5 of Weglot plugin, the auto redirection feature works on all pages. Here is how to restrict it to the homepage only
Since version 3.5, the auto-redirect (auto-switch) feature works on every page. For example, with a **French** browser:
* `/` is redirected to `/fr/`
* `/contact` is redirected to `/fr/contact`
To restrict the auto-redirect to the homepage only:
```php
// Add this using the "Code Snippets" plugin or directly in functions.php
add_filter( 'weglot_autoredirect_only_home', '__return_true' );
```
# Proxify Url
Since the version 4.2 of Weglot plugin, you have a filter to proxify an url
Since version 4.2, a filter lets you route ("proxify") a resource URL through Weglot. A proxified URL is rewritten to this form:
`proxy.weglot.com/API_KEY/LANGUAGE_FROM/LANGUAGE_TO/my.ressource.io`
To proxify one or more URLs, use the `weglot_proxify_urls` filter:
```php
// Add this using the "Code Snippets" plugin or directly in functions.php
add_filter( 'weglot_proxify_urls', 'proxify_callback' );
function proxify_callback( $urls_to_proxify ) {
$urls_to_proxify[] = 'https://my.ressource.io/';
return $urls_to_proxify;
}
```
You can add several URLs to the array.
# Translate pdf for Woocommerce pdf invoice
Since the version 3.7 of Weglot plugin, you can translate pdf generate by WooCommerce PDF Invoices & Packing Slips plugin
Since version 3.7, Weglot can translate the PDFs generated by the *WooCommerce PDF Invoices & Packing Slips* plugin. This is disabled by default.
To enable it:
```php
// Add this using the "Code Snippets" plugin or directly in functions.php
add_filter( 'weglot_translate_pdf', '__return_true' );
```
# Translate pdf with Gravity pdf
Since the version 3.7 of Weglot plugin, you can translate pdf generate by Gravity PDF.
Below is an example of how to translate a PDF generated by Gravity PDF into the current language, based on the `gfpdf_pdf_html_output` filter documented here:
```php
// Add this using the "Code Snippets" plugin.
// Create a new meta entry to store the weglot_language on Gravity Forms entries.
add_filter( 'gform_entry_meta', 'get_entry_meta', 10, 2 );
function get_entry_meta( $entry_meta, $form_id ) {
$entry_meta['weglot_language'] = array(
'label' => 'Weglot language',
'is_numeric' => false,
'is_default_column' => true,
'update_entry_meta_callback' => 'update_entry_meta',
);
return $entry_meta;
}
function update_entry_meta( $key, $lead, $form ) {
return ''; // Return the value of the entry meta.
}
// Store the Weglot language on submission.
add_action( 'gform_after_submission', 'after_submission' );
function after_submission( $entry ) {
$request_url_services = weglot_get_service( 'Request_Url_Service_Weglot' );
$current_language = $request_url_services->get_current_language()->getExternalCode();
gform_update_meta( $entry['id'], 'weglot_language', $current_language );
}
// Translate the PDF using the stored language.
add_filter( 'gfpdf_pdf_html_output', function( $html, $form, $entry, $settings, $Helper_PDF ) {
$weglot_language = gform_get_meta( $entry['id'], 'weglot_language' );
if ( $weglot_language === weglot_get_original_language() ) {
return $html;
}
$qp = new GFPDF\Helper\Helper_QueryPath();
$pdf_translate_service = weglot_get_service( 'Pdf_Translate_Service_Weglot' );
$html = $pdf_translate_service->translate_pdf( $html, $weglot_language );
$wrapper = $qp->html5( $html['content'] );
return $wrapper->top( 'html' )->innerHTML5();
}, 10, 5 );
```
# Translate Dublin core meta (or other meta)
Dublin Core is a collection of meta tags to describe your content.These tags are automatically generated. Recognised by states/governments, these are used by directories, Bing, Baidu and Yandex.
Dublin Core is a set of meta tags describing your content (recognised by several search engines and directories). They are not translated by default, but you can register them with the `weglot_get_dom_checkers` filter.
Translate a single meta (e.g. ``):
```php
add_filter( 'weglot_get_dom_checkers', 'dublin_core_weglot_dom_check' );
function dublin_core_weglot_dom_check( $dom_checkers ) {
if ( ! class_exists( 'Dublin_Core_Meta' ) ) {
class Dublin_Core_Meta extends Weglot\Parser\Check\Dom\AbstractDomChecker {
const DOM = 'meta[name="dc.title"]';
const PROPERTY = 'content';
const WORD_TYPE = Weglot\Client\Api\Enum\WordType::META_CONTENT;
}
$dom_checkers[] = '\Dublin_Core_Meta';
}
return $dom_checkers;
}
```
To target several meta tags at once, list them in the `DOM` selector (comma-separated):
```php
const DOM = 'meta[name="dc.title"],meta[name="dc.description"]';
```
# How to not translate specific ajax action
Weglot translates the response of admin-ajax actions by default. If a specific AJAX action should not be translated, add it to the list with the `weglot_ajax_no_translate` filter.
#### Example: excluding the `loadmore` ajax action
```php
add_filter( 'weglot_ajax_no_translate', 'custom_ajax_no_translate', 10, 1 );
function custom_ajax_no_translate( $ajax_action ) {
$ajax_action[] = 'loadmore';
return $ajax_action;
}
```
# How to get translated url programmatically
Below an example of how to get a translated url programmatically
```php
//get services
$language_services = weglot_get_service( 'Language_Service_Weglot' );
$request_url_services = weglot_get_service( 'Request_Url_Service_Weglot' );
//the url we want to get on other languages
$url = "http://myurl.local/hello-world/";
//create url object
$wg_url = $request_url_services->create_url_object( $url );
// get a language (in my case fr)
$language = $language_services->get_language_from_internal('fr');
//display url for my language
$wg_url->getForLanguage( $language );
```
# How to set WP locale based on Weglot current language
Below is an example of how to set the WordPress locale based on the current Weglot language, using the WordPress `locale` filter:
```php
add_filter( 'locale', 'weglot_set_locale' );
function weglot_set_locale( $lang ) {
if ( function_exists( 'weglot_get_current_language' ) ) {
$current_language = weglot_get_current_language();
switch ( $current_language ) {
case 'sv':
return 'sv_SE';
case 'en':
return 'en_US';
case 'no':
return 'nb_NO';
default:
return $lang;
}
}
return $lang;
}
```
# How to translate mail from Photo Reviews for WooCommerce
Works since version 1.2.7 of Photo Reviews for WooCommerce
The following code translates the reminder emails sent by *Photo Reviews for WooCommerce*, using the order's recorded language (stored by Weglot in the `weglot_language` order meta).
```php
use Weglot\Parser\Parser;
use Weglot\Parser\ConfigProvider\ServerConfigProvider;
function wg_viwcpr_email_reminder_get_content( $content, $order_id ) {
$parser_services = weglot_get_service( 'Parser_Service_Weglot' );
$language_services = weglot_get_service( 'Language_Service_Weglot' );
$original_language = $language_services->get_original_language()->getInternalCode();
$woocommerce_order_language = get_post_meta( $order_id, 'weglot_language', true ); // phpcs:ignore
if ( $woocommerce_order_language == weglot_get_original_language() ) {
return $content;
}
$config = new ServerConfigProvider();
$client = $parser_services->get_client();
$parser = new Parser( $client, $config, [] );
$content = $parser->translate( $content, $original_language, $woocommerce_order_language ); // phpcs:ignore
return $content;
}
function wg_viwcpr_email_reminder_get_subject( $subject, $order_id ) {
$parser_services = weglot_get_service( 'Parser_Service_Weglot' );
$language_services = weglot_get_service( 'Language_Service_Weglot' );
$original_language = $language_services->get_original_language()->getInternalCode();
$woocommerce_order_language = get_post_meta( $order_id, 'weglot_language', true ); // phpcs:ignore
if ( $woocommerce_order_language == weglot_get_original_language() ) {
return $subject;
}
$config = new ServerConfigProvider();
$client = $parser_services->get_client();
$parser = new Parser( $client, $config, [] );
$subject = $parser->translate( $subject, $original_language, $woocommerce_order_language ); // phpcs:ignore
return $subject;
}
add_filter( 'viwcpr_email_reminder_get_content', 'wg_viwcpr_email_reminder_get_content', 10, 2 );
add_filter( 'viwcpr_email_reminder_get_subject', 'wg_viwcpr_email_reminder_get_subject', 10, 2 );
```
# How to translate schema from schema.org generate by Yoast plugin
On this example we use a filter to translate some entry from our schema based on this doc : https\://developer.yoast.com/features/schema/api/
```php
add_filter( 'wpseo_schema_graph', 'wg_schema', 10, 2 );
function wg_schema( $data, $context ) {
foreach ( $data as $key => $value ) {
if ( $value['@type'] === 'WebPage' || $value['@type'] === 'WebSite') {
$data[$key]['@id'] = weglot_get_current_full_url();
$data[$key]['url'] = weglot_get_current_full_url();
$data[$key]['inLanguage'] = weglot_get_current_language();
}
if ( $value['@type'] === 'ImageObject' || $value['@type'] === 'primaryImageOfPage') {
$data[$key]['inLanguage'] = weglot_get_current_language();
}
}
return $data;
}
```
# How to translate email sending by plugin WP Mail SMTP
On this example we use a filter to translate our email message based on this doc : https\://wpmailsmtp.com/docs/setting-a-custom-reply-to-email/
{% hint style="info" %}
Weglot can translate `wp_mail` emails natively — just enable the **Translate emails** option in the Weglot settings. Use the snippet below only if you need custom handling on top of the built-in option (for example with WP Mail SMTP).
{% endhint %}
This example translates the email message body into the current language:
```php
function wp_mail_smtp_weglot( $args ) {
$original_lang = weglot_get_original_language();
$current_language = weglot_get_current_language();
if ( $original_lang == $current_language ) {
return $args;
}
if ( ! empty( $args['message'] ) ) {
$translate_service = weglot_get_service( 'Pdf_Translate_Service_Weglot' );
$translate_message = $translate_service->translate_pdf( $args['message'], $current_language );
$args['message'] = $translate_message['content'];
}
return $args;
}
add_filter( 'wp_mail', 'wp_mail_smtp_weglot', PHP_INT_MAX );
```
# How to hide the Weglot admin button for non administrator roles
In this example, we hide the Weglot button in the top navigation for users without the role of administrator
```php
if(is_user_logged_in()){
$user = wp_get_current_user();
if ( !in_array( 'administrator', (array) $user->roles ) ) {
add_action( 'admin_head', 'hide_wg_button' );
}
}
function hide_wg_button() {
echo "";
}
```
# Exemple of snippet to translate search from JetSearch plugin
In this example, we use custom code to translate the search result provide by the plugin jetSearch
To translate the results of the JetSearch plugin, reverse-translate the search term back into your original language before the query runs, then declare the JSON keys JetSearch returns so Weglot translates them.
```php
add_action( 'jet-search/ajax-search/search-query', 'modify_weglot_search_query', 10, 2 );
function modify_weglot_search_query( $instance, $args ) {
$parser_services = weglot_get_service( 'Parser_Service_Weglot' );
$parser = $parser_services->get_parser();
$language_services = weglot_get_service( 'Language_Service_Weglot' );
$original_language = $language_services->get_original_language()->getInternalCode();
$destination_languages = weglot_get_destination_languages();
$current_language = weglot_get_current_language();
if ( $original_language === $current_language ) {
return;
}
foreach ( $destination_languages as $destination ) {
if ( $destination['language_to'] === $current_language && ! empty( $destination['custom_code'] ) ) {
$current_language = substr( $destination['custom_code'], 0, 2 );
}
}
if ( ! empty( $instance->search_query['s'] ) ) {
$instance->search_query['s'] = $parser->translate( $instance->search_query['s'], $current_language, $original_language );
}
}
add_filter( 'weglot_add_json_keys', 'custom_weglot_add_json_keys' );
function custom_weglot_add_json_keys( $keys ) {
$keys[] = 'title';
$keys[] = 'link';
$keys[] = 'before_title';
$keys[] = 'posts';
return $keys;
}
```
# Example of snippet to translate your checkout element (override/added by the Funnel Builder plugin)
```php
add_filter('woocommerce_update_order_review_fragments', 'wg_update_checkout', 999, 2);
function wg_update_checkout($arr) {
$pdf_translate_service = weglot_get_service( 'Pdf_Translate_Service_Weglot' );
$original_lang = weglot_get_original_language();
$current_language = weglot_get_current_language();
if ( $original_lang == $current_language ) {
return $arr;
}
$pot = $pdf_translate_service->translate_pdf( $arr['place_order_text'], $current_language );
$arr['place_order_text'] = $pot['content'];
return $arr;
}
```
# LScache
Compatibility issue with LScache
LScache uses so called “Cache Vary”. That means each URL can be cached with different cache copies depending on user related facts like cookie, device and many others. The problem is that Weglot uses PHP and detects language using PHP, but if a page is cached there is no more PHP interpretor, because a cached URL is pure plain text and plain text can’t execute PHP. To make Weglot work with LScache a cookie must be set with different cookie value depending on the selected language. Then this cookie can be used for cache vary so each language gets its own cached copy.
To make it works you can modifiy your Litespeed Vhost with this code :
```php
RewriteEngine onCacheLookup on
## Create a separate cache for each language [create a rule for each language you have on your website except the fallback language. In this example we have: FR (original language) + ES (target language) + EN (target but fallback language)] ##
## FR cache ##
RewriteCond %{HTTP:Accept-Language} ^fr [NC]RewriteRule .* - [E=Cache-Control:vary=%{ENV:LSCACHE_VARY_VALUE}+french]
## ES cache ##
RewriteCond %{HTTP:Accept-Language} ^es [NC]RewriteRule .* - [E=Cache-Control:vary=%{ENV:LSCACHE_VARY_VALUE}+spain]
## Create a separate cache if the browser is different from the website - add it imperatively or it will cause issue if the cache is made with the wrong language ##
RewriteCond %{HTTP_COOKIE} ^.*WG_CHOOSE_ORIGINAL.*$RewriteRule .* - [E=Cache-Control:vary=%{ENV:LSCACHE_VARY_VALUE}+wg_choose_original]
```
Be careful, in some cases, if the Litespeed server is a “fake”, configured with reverse proxies by the host, this code must be added to the Litespeed Vhost. Unfortunately, some hosts do not allow this...
# How to fix live builder issue with Weglot
Compatibility issue with live theme builder
Weglot is not intended to translate backoffice elements. More and more site builders offer the live builder feature. Some of its live builders will come into conflict with Weglot because Weglot will attempt to translate elements that are not wanted at that time. To avoid this we will ask Weglot not to translate when we are in the live builder.
Let’s take the example of Avada theme builder. When we are in the live builder we have the get fb-edit variable in the url so we can use this snippet:
Here another exemple with elementor : we use a hook instead of url parameters :
```php
function weglot_deactivate_elementor() {
add_filter( 'weglot_active_translation', '__return_false', 99999 );
}
add_action( 'elementor/init', 'weglot_deactivate_elementor' );
```
# Add translated url to Rankmath sitemap index
First step, add this snippet to be sure to purge the sitemap caching
```php
/**
* Filter if XML sitemap transient cache is enabled.
*
* @param boolean $unsigned Enable cache or not, defaults to true
*/
add_filter( 'rank_math/sitemap/enable_caching', '__return_false');
```
Add this filter. For the moment you need to add the list of url you want to translate into your sitemap
```php
add_filter( 'rank_math/sitemap/index', function( $xml ) {
// Fetch Weglot services
$language_services = weglot_get_service( 'Language_Service_Weglot' );
$request_url_services = weglot_get_service( 'Request_Url_Service_Weglot' );
// List of URLs to be translated
$urls = [
"http://beta-429.local/post-sitemap.xml",
"http://beta-429.local/page-sitemap.xml",
"http://beta-429.local/category-sitemap.xml",
];
$destination_languages = weglot_get_destination_languages();
foreach ( $urls as $url ) {
$wg_url = $request_url_services->create_url_object( $url );
// Iterate over each destination language
foreach ( $destination_languages as $language_code ) {
$language = $language_services->get_language_from_internal( $language_code['language_to'] );
$translated_url = $wg_url->getForLanguage( $language );
$xml .= '
' . esc_url( $translated_url ) . '' . esc_html( date( 'c' ) ) . '';
}
}
return $xml;
}, 999 );
```
# Advanced Woo Search X Weglot
Advanced Woo Search (aws) is a plugin to make advance search with WooCommerce. You can find the plugin here : https\://wordpress.org/plugins/advanced-woo-search/
To make Advanced Woo Search return results in translated languages, reverse-translate the search terms into your original language before the search runs. The right hook (see the [Advanced Woo Search hooks reference](https://advanced-woo-search.com/guide/hooks-reference/)) is `aws_search_terms`.
```php
use WeglotWP\Helpers\Helper_API;
add_filter( 'aws_search_terms', 'my_aws_search_terms' );
function my_aws_search_terms( $terms ) {
$original_language = weglot_get_original_language();
$current_language = weglot_get_current_language();
if ( $original_language === $current_language || ! $terms ) {
return $terms;
}
$option_services = weglot_get_service( 'Option_Service_Weglot' );
$api_key_private = $option_services->get_api_key_private();
foreach ( $terms as $key => $term ) {
$request_body = wp_json_encode( array(
'l_from' => $current_language,
'l_to' => $original_language,
'request_url' => home_url( '/' ),
'words' => array(
array( 'w' => $term, 't' => 1 ),
),
) );
$url = sprintf( '%s/translate?api_key=%s', Helper_API::get_api_url(), $api_key_private );
$response = wp_remote_post( $url, array(
'body' => $request_body,
'headers' => array( 'Content-Type' => 'application/json' ),
'method' => 'POST',
'data_format' => 'body',
) );
if ( is_wp_error( $response ) ) {
continue; // Keep the original term if the request fails.
}
$response_data = json_decode( wp_remote_retrieve_body( $response ), true );
if ( isset( $response_data['to_words'][0] ) ) {
$terms[ $key ] = $response_data['to_words'][0];
}
}
return $terms;
}
```
# Conditionally Disabling Weglot Translation for Specific URLs
When using Weglot on your website, you might occasionally encounter issues where its translation processes interfere with certain functionalities, like generating PDFs or handling custom endpoints. In
Suppose you’re facing an issue where generating PDFs is not working correctly due to Weglot's translation being applied to those URLs. In this case, instead of disabling the entire Weglot plugin, you can selectively disable its translation process for specific URLs.
```php
add_action('init', 'conditionally_apply_weglot_translation');
function conditionally_apply_weglot_translation() {
$current_url = $_SERVER['REQUEST_URI'];
// Check if the current URL contains 'front-end'
if (strpos($current_url, 'front-end') !== false) {
// Disable Weglot translation for this specific request
add_filter('weglot_active_translation_before_process', function() {
return false;
});
}
}
```
**Why Use This Approach?**
* **Avoid full deactivation**: Instead of disabling the entire Weglot plugin (which affects your whole site), this solution allows you to keep Weglot active while bypassing translation only for specific scenarios.
* **Resolve conflicts efficiently**: For example, if generating PDFs or handling specific routes fails due to translations, disabling Weglot only for those URLs resolves the issue without affecting the rest of your website.
# Weglot filters
All Weglot filters you can call to modify translations
Weglot plugin is exposing actions and filters that can be called in your code.
# weglot\_translate\_email
This filter allow you to prevent weglot translate email even if the option is checks on your options.
```php
add_filter( 'weglot_translate_email', '__return_false' );
```
# weglot\_cancel\_init
This filter allow you to prevent weglot to be load.
### weglot\_cancel\_init
```php
add_filter( 'weglot_cancel_init', '__return_true' );
```
# weglot\_translate\_email\_languages\_forced
Weglot prevent to translate emails that are fro admins. But you can force it by adding this filter.
```php
add_filter( 'weglot_translate_email_languages_forced', '__return_true' );
```
# weglot\_menu\_parent\_menu\_item\_title
When the language switcher is added through the WordPress menu in dropdown mode, its parent item shows a default title ("Choose your language"). Use this filter to change it.
```php
add_filter( 'weglot_menu_parent_menu_item_title', 'custom_weglot_menu_parent_menu_item_title' );
function custom_weglot_menu_parent_menu_item_title( $title ) {
return 'Choose your language';
}
```
# weglot\_active\_current\_menu\_item
With this filter you can manage if you want to add the current-item-menu class into your switcher element (menu version).
```php
add_filter( 'weglot_active_current_menu_item', '__return_true' );
```
# weglot\_ajax\_no\_translate
This filter help you prevent Weglot to translate some ajax action. Here the list of action we don't translate :
```php
add_filter( 'weglot_ajax_no_translate', [] );
```
```
array(
'add-menu-item', // WP Core.
'query-attachments', // WP Core.
'avia_ajax_switch_menu_walker', // Enfold theme.
'query-themes', // WP Core.
'wpestate_ajax_check_booking_valability_internal', // WP Estate theme.
'wpestate_ajax_add_booking', // WP Estate theme.
'wpestate_ajax_check_booking_valability', // WP Estate theme.
'mailster_get_template', // Mailster Pro.
'mmp_map_settings', // MMP Map.
'elementor_ajax', // Elementor since 2.5.
'ct_get_svg_icon_sets', // Oxygen.
'oxy_render_nav_menu', // Oxygen.
'hotel_booking_ajax_add_to_cart', // Hotel booking plugin.
'imagify_get_admin_bar_profile', // Imagify Admin Bar.
'el_check_user_login', // Event list plugin.
'wcfm_ajax_controller', // wcfm_ajax_controller.
'jet_ajax_search', // jet_ajax_search.
'woofc_update_qty', // jet_ajax_search.
)
```
With the filter you can update this array by add or unset array index.
# weglot\_active\_translation\_before\_process
This filter allow you to interrupt translation process before Weglot check redirection needed.
```php
add_filter( 'weglot_active_translation_before_process', '__return_false' );
```
# weglot\_active\_translation\_before\_treat\_page
This filter allow you to interrupt translation process after Weglot have check redirection needed.
```php
add_filter( 'weglot_active_translation_before_treat_page', '__return_false' );
```
# weglot\_debug\_file
In the Weglot plugin you can active a debug mode.
To activate the debug mode the steps are:
* In Weglot.php set **`WEGLOT_DEBUG`** to true
* Create a file **`content.html`** on Weglot plugin dir root
```php
add_filter( 'weglot_debug_file', 'path to your file' );
```
With this filter you can access debug mode from another file instead of :
```
WEGLOT_DIR . '/content.html'
```
# weglot\_autoredirect\_only\_home
This filter allow you to restrict autoredirect to the homepage only.
```php
add_filter( 'weglot_autoredirect_only_home', '__return_true' );
```
# weglot\_autoredirect\_skip
This filter allow you to deactivate the autoswitch feature even if the option is activate.
```php
add_filter( 'weglot_autoredirect_skip', '__return_true' );
```
# weglot\_remove\_google\_translate
By default, Weglot prevent google translating page but with this flter you can enable this google feature
```php
add_filter( 'weglot_autoredirect_only_home', '__return_false' );
```
# weglot\_add\_hreflang
This filter allow you to prevent Weglot add hreflangs if you want to add yours
```php
add_filter( 'weglot_add_hreflang', '__return_false' );
```
# weglot\_get\_replace\_modify\_link
This filter allow you to add pattern to define kind of link you want to translate.
here the list of pattern we already treat on Weglot:
```php
array(
'a' => '/]+?)?href=(\"|\')([^\s\>]+?)(\"|\')([^\>]+?)?>/',
'datalink' => '/<([^\>]+?)?data-link=(\"|\')([^\s\>]+?)(\"|\')([^\>]+?)?>/',
'dataurl' => '/<([^\>]+?)?data-url=(\"|\')([^\s\>]+?)(\"|\')([^\>]+?)?>/',
'datacart' => '/<([^\>]+?)?data-cart-url=(\"|\')([^\s\>]+?)(\"|\')([^\>]+?)?>/',
'form' => '/]+?)?action=(\"|\')([^\s\>]+?)(\"|\')/',
'canonical' => '/]+?)(\"|\')/',
'amp' => '/]+?)(\"|\')/',
'meta' => '/]+?)(\"|\')/',
'next' => '/]+?)(\"|\')/',
'prev' => '/]+?)(\"|\')/',
);
```
```php
add_filter( 'weglot_get_replace_modify_link', [] );
```
Here 2 exemples of how to use this filter :
```html
http://debug-wp-woo.local/shop/
```
To translate the link into the attribute data-link-2 you cn use this code :
```php
add_filter( 'weglot_get_replace_modify_link', 'custom_weglot_get_replace_modify_link' );
function custom_weglot_get_replace_modify_link( $data ) {
$data['datalink2'] = '/<([^\>]+?)?data-link2=(\"|\')([^\s\>]+?)(\"|\')([^\>]+?)?>/';
return $data;
}
function replace_datalink2( $translated_page, $current_url, $quote1, $quote2, $sometags = null, $sometags2 = null ) {
$request_url_services = weglot_get_service( 'Request_Url_Service_Weglot' );
$replace_url_Service = weglot_get_service( 'Replace_Link_Service_Weglot' );
$current_language = $request_url_services->get_current_language();
$translated_page = preg_replace( '/<' . preg_quote( $sometags, '/' ) . 'data-link2=' . preg_quote( $quote1 . $current_url . $quote2, '/' ) . '/', '<' . $sometags . 'data-link2=' . $quote1 . $replace_url_Service->replace_url( $current_url, $current_language ) . $quote2, $translated_page );
return $translated_page;
}
```
Now try with a more complexe case :
```html
http://debug-wp-woo.local/shop/
```
```php
add_filter( 'weglot_get_replace_modify_link', 'custom_weglot_get_replace_modify_link_2' );
function custom_weglot_get_replace_modify_link_2( $data ) {
$data['dataactions'] = '/]*?data-actions=(["\'].*?url:)([^"\'>]+).*?>(.*?)<\/div>/';
return $data;
}
function replace_dataactions( $translated_page, $current_url, $quote1, $quote2, $sometags = null, $sometags2 = null ) {
$request_url_services = weglot_get_service( 'Request_Url_Service_Weglot' );
$replace_url_Service = weglot_get_service( 'Replace_Link_Service_Weglot' );
$current_language = $request_url_services->get_current_language();
$sometags = 'div ';
$quote1 = '"o:click;a:simplelink;target:_self;url:';
$quote2 = ';"';
$translated_page = preg_replace( '/<' . preg_quote( $sometags, '/' ) . 'data-actions=' . preg_quote( $quote1 . $current_url . $quote2, '/' ) . '/', '<' . $sometags . 'data-actions=' . $quote1 . $replace_url_Service->replace_url( $current_url, $current_language ) . $quote2, $translated_page );
return $translated_page;
}
```
# get\_replace\_modify\_link\_in\_xml
This filter allow you to add pattern to define kind of link you want to translate in xml.
here the list of pattern we already treat on Weglot:
```php
array('loc' => '/(.*?)<\/loc>/');
```
```php
add_filter( 'get_replace_modify_link_in_xml', [] );
```
# weglot\_get\_flag\_class
This filter allow to add or remove class use to display flag on switcher
```php
add_filter( 'weglot_get_flag_class', 'list of class' );
```
# weglot\_get\_name\_with\_language\_entry
With this filter you can modifiy the name of language we diplay on switcher for each languages
```php
add_filter( 'weglot_get_name_with_language_entry', $name, $language_entry );
```
# weglot\_get\_class\_dropdown
This filter allow you to modify list of class use to display our switcher dropdown.
```php
add_filter( 'weglot_get_class_dropdown', '' );
```
# weglot\_button\_html
this filter allows you yo get the html generate for our switcher and modify it.
You can find an exemple [here](https://developers.weglot.com/wordpress/use-cases/language-selector-styling#example-adding-code-before-after-the-button).
```php
add_filter( 'weglot_button_html', 'custom_weglot_button_html', 10, 2 );
```
# weglot\_get\_dom\_checkers
This filter allow you to add rule to our dom checker. You can add rule to telle Weglot what kind of node need to be translate.
You've an exemple here:
# weglot\_replace\_div\_id
This filter allow you to get the translated content after we have replace the \
\
with the switcher
```php
add_filter( 'weglot_autoredirect_only_home', '__return_true' );
```
# weglot\_replace\_weglot\_menu
This filter allow to modify the content before we add the switcher(s)
```php
add_filter( 'weglot_replace_weglot_menu', $dom );
```
# weglot\_render\_default\_button
This filter allows you to modifiy the content after the default switcher is added
```php
add_filter( 'weglot_render_default_button', $dom );
```
# weglot\_render\_switcher\_editor\_button
This filter allow you to modifiy the translated content after the custom switcher is added.
```php
add_filter( 'weglot_render_switcher_editor_button', $dom );
```
# weglot\_href\_lang
With this filter you can modifiy hreflangs generate by Weglot before we add them.
Lets you alter the hreflang block Weglot outputs in the `` (for example to swap a language code).
```php
add_filter( 'weglot_href_lang', 'custom_weglot_href_lang' );
function custom_weglot_href_lang( $render ) {
$render = str_replace( 'hreflang="zh-HK"', 'hreflang="tw"', $render );
return $render;
}
```
# weglot\_get\_options\_from\_cdn\_cache
This filter allow you to prevent to load Weglot settings from transient.
```php
add_filter( 'weglot_get_options_from_cdn_cache', '__return_false' );
```
# weglot\_get\_options\_from\_cdn\_cache\_duration
With this filter you can modifiy the duration of cache where we save Weglot settings. By default we fix it to 300 seconds
```php
add_filter( 'weglot_get_options_from_cdn_cache_duration', 300 );
```
# weglot\_get\_slugs\_from\_cache
This filter allow you to get your slug directly from the API instead of getting them from transient. Be carefull using this filter.
```php
add_filter( 'weglot_get_slugs_from_cache', '__return_false' );
```
# weglot\_get\_slugs\_cache\_duration
This filter allow you to change the duration of cache we store the slugs. By default is setting to 0.
Translated URL slugs are cached in a transient. By default the duration is `0` (no explicit expiration set on the transient). Use this filter to set a custom cache duration, in seconds.
```php
add_filter( 'weglot_get_slugs_cache_duration', 'custom_weglot_get_slugs_cache_duration' );
function custom_weglot_get_slugs_cache_duration( $duration ) {
return HOUR_IN_SECONDS;
}
```
# weglot\_exclude\_blocks
This filter allow you to modifiy the array of exclude blocks.
```php
add_filter( 'weglot_exclude_blocks', [] );
```
# weglot\_exclude\_urls
This filter allow you to modifiy the list of your excluded url.
```php
add_filter( 'weglot_exclude_urls', $exclude_urls );
```
# weglot\_get\_parser\_ignored\_nodes
This filter allow you to modify the list of node ignored by Weglot.
the default list is :
```php
$ignoredNodes = [
'strong', 'b',
'em', 'i',
'small', 'big',
'sub', 'sup',
'abbr',
'acronym',
'bdo',
'cite',
'kbd',
'q',
];
```
```php
add_filter( 'weglot_get_parser_ignored_nodes', $ignored_nodes );
```
# weglot\_navigator\_language
With this filter you can modifiy the browser language(s) detect by Weglot.
Lets you change the list of browser languages Weglot reads from the visitor to decide the redirect language. Useful together with a custom language code.
```php
add_filter( 'weglot_navigator_language', 'custom_weglot_navigator_language' );
function custom_weglot_navigator_language( $navigator_languages ) {
return $navigator_languages;
}
```
# weglot\_url\_auto\_redirect
This filter can be use to modify the url where use will be redirect if the autoswitch option is activate.
When the browser-language auto-redirect runs, this filter lets you change the destination URL.
```php
add_filter( 'weglot_url_auto_redirect', 'custom_weglot_url_auto_redirect' );
function custom_weglot_url_auto_redirect( $url ) {
return $url;
}
```
# weglot\_replace\_url
This filter allow you to modifiy the replaced url when it is translated.
```php
add_filter( 'weglot_replace_url', $replaced_url );
```
# weglot\_replace\_link
This filter allow you to modifiy the dom after the link has benne replaced.
This filter lets you modify the DOM while Weglot replaces links. It receives the DOM string being processed and must return it.
```php
add_filter( 'weglot_replace_link', 'custom_weglot_replace_link' );
function custom_weglot_replace_link( $dom ) {
// Modify $dom here.
return $dom;
}
```
# weglot\_ajax\_replace\_urls
When Weglot translate json content, we don't translate all entry. With this filter you can modifiy the keys we translate for url.
by default we translate this keys :
```php
[ 'redirecturl', 'url', 'link' ]
```
```php
add_filter( 'weglot_ajax_replace_urls', [] );
```
# weglot\_proxify\_urls
This filter allow you to modify the list of url you want to proxify.
```php
add_filter( 'weglot_proxify_urls', [] );
```
# weglot\_add\_json\_keys
With this filter you can add keys Weglot msut translate into a json content.
```php
add_filter( 'weglot_add_json_keys', [] );
```
# weglot\_json\_treat\_page
This filter allow you to modifiy the translated content when this one is a json.
```php
add_filter( 'weglot_json_treat_page', $translated_content );
```
# weglot\_html\_treat\_page
This filter allow you to modifiy the translated content when this one is html.
```php
add_filter( 'weglot_html_treat_page', $translated_content );
```
# Copy of weglot\_xml\_treat\_page
This filter allow you to modifiy the translated content when this one is xml.
```php
add_filter( 'weglot_xml_treat_page', $translated_content );
```
# weglot\_render\_dom
This filter allow to modify the translated content after putting meta and replace link.
```php
add_filter( 'weglot_render_dom', $dom );
```
# weglot\_default\_current\_language\_empty
When we not able to find the current language, we set it to the original language by default. This filter allow you to modifiy.
```php
add_filter( 'weglot_default_current_language_empty', '__return_true' );
```
# weglot\_active\_translation
The master switch for Weglot's page translation. Return `false` to disable translation entirely.
```php
add_filter( 'weglot_active_translation', '__return_false' );
```
# weglot\_active\_slugs
Controls whether Weglot loads and applies translated URL slugs. Return `false` to disable them.
```php
add_filter( 'weglot_active_slugs', '__return_false' );
```
# weglot\_is\_eligible\_url
Lets you force whether a URL is translatable. The filter receives the current decision and the URL object.
```php
add_filter( 'weglot_is_eligible_url', 'custom_weglot_is_eligible_url', 10, 2 );
function custom_weglot_is_eligible_url( $eligible, $weglot_url ) {
// return true or false to force eligibility
return $eligible;
}
```
# weglot\_autoredirect\_js
Return `true` to perform the auto-redirect via the front-end JS library instead of server-side. Useful behind aggressive caching that interferes with server redirects.
```php
add_filter( 'weglot_autoredirect_js', '__return_true' );
```
# weglot\_add\_trailing\_slash
By default Weglot adds a trailing slash to translated links. Return `false` to keep links without a trailing slash.
```php
add_filter( 'weglot_add_trailing_slash', '__return_false' );
```
# weglot\_no\_replace\_a\_href
Links whose `href` contains this string are left untouched during link replacement. The default is `wp-content/uploads`.
```php
add_filter( 'weglot_no_replace_a_href', 'custom_weglot_no_replace_a_href' );
function custom_weglot_no_replace_a_href( $condition ) {
return 'my-folder';
}
```
# weglot\_url\_object
Advanced. Lets you replace the `Weglot\Util\Url` object Weglot uses for the current request.
```php
add_filter( 'weglot_url_object', 'custom_weglot_url_object' );
function custom_weglot_url_object( $weglot_url ) {
return $weglot_url;
}
```
# weglot\_language\_code\_replace
Replace Weglot's default language code with a custom one (e.g. `tw` → `zh-HK`). See the dedicated use case for the full example.
```php
add_filter( 'weglot_language_code_replace', 'custom_weglot_language_code_replace' );
function custom_weglot_language_code_replace( $replacements ) {
$replacements['tw'] = 'zh-HK';
return $replacements;
}
```
# weglot\_get\_translation\_engine
Returns the translation engine version used by the project.
```php
add_filter( 'weglot_get_translation_engine', 'custom_weglot_get_translation_engine' );
function custom_weglot_get_translation_engine( $engine ) {
return $engine;
}
```
---
[Next Page](/llms-full.txt/1)