---
title: "Normalização de texto em árabe para busca e RAG | BroadRouter"
description: "Tashkeel, alef, ta marbuta, hamza, letras persas, dígitos e Unicode: quais regras de normalização do árabe ajudam a busca, quais atrapalham, com Python testado."
url: https://broadrouter.com/pt/blog/arabic-text-normalization-search/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/arabic-text-normalization-search/) (atualizado em 2026-11-16).

# Normalizar texto em árabe para busca e RAG: o que mudar e o que não

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15 · Atualizado em 2026-11-16

Para índices de busca e RAG, normalize do mesmo jeito a cópia indexada e cada consulta: Unicode NFKC, remoção de tashkeel e tatweel, unificação das formas de alef, ى para ي e ة para ه, conversão de dígitos. Guarde o texto original para exibição e para o LLM. Trate os suportes da hamza e o ta marbuta como ajustáveis: aumentam a recall, mas juntam algumas palavras distintas.

## Pontos principais

-   Normalize a chave de busca, nunca o texto que você exibe ou cita. Guarde o original ao lado.
-   Num estudo clássico sobre notícias em árabe do TREC-2001, só a normalização elevou a precisão média de 0,194 para 0,238, e com stemming leve por cima chegou a 0,376.
-   Rode primeiro o Unicode NFKC. Ele compõe a hamza decomposta, desfaz formas de apresentação e ligaduras e torna confiáveis as regras seguintes.
-   As bibliotecas discordam. O normalize\_alef do PyArabic transforma ى em ا; o CAMeL Tools transforma ى em ي. Escolha um conjunto de regras e use-o em todo lugar.
-   Para busca por embeddings, teste entrada normalizada e bruta com as suas próprias consultas. As regras de normalização foram medidas em busca por palavras-chave.

**Nesta página**

1.  A normalização realmente melhora a recuperação?
2.  O que normalizar, e quanto custa cada regra?
3.  Por que a normalização Unicode deve vir primeiro?
4.  O que não normalizar?
5.  Em que CAMeL Tools, PyArabic e Lucene diferem?
6.  Como é um normalizador testado?
7.  Como a normalização se encaixa em embeddings e RAG?
8.  Onde a BroadNet Inference entra

O árabe permite escrever a mesma palavra de vários jeitos. O usuário digita احمد; o documento traz أَحْمَد. Um índice de busca que compara caracteres exatos perde essa correspondência, e o mesmo acontece com a metade de palavras-chave de um pipeline RAG. A normalização resolve isso levando as variantes a uma única forma antes da comparação. Feita sem cuidado, ela também junta palavras que significam coisas diferentes. Este post vai regra por regra: o que cada uma faz, quando aplicá-la, o que ela quebra e como as principais bibliotecas diferem. No fim, há código Python testado.

Para o pipeline RAG completo em árabe (chunking, busca híbrida, respostas com citações), veja [RAG em árabe que funciona](https://broadrouter.com/pt/blog/arabic-rag-search/). Este post se aprofunda na etapa de normalização.

## A normalização realmente melhora a recuperação?

Sim, para busca por palavras-chave, e as evidências são antigas, mas claras. Larkey, Ballesteros e Connell (SIGIR 2002) testaram recuperação em árabe na coleção de notícias do TREC-2001. Antes do stemming, eles normalizaram corpus e consultas: removeram diacríticos e pontuação, unificaram as formas de alef e converteram ى e ة no fim das palavras. Os resultados monolíngues, com consultas não expandidas:

| Processamento | Precisão média | Variação em relação ao bruto (a partir dos valores arredondados) |
| --- | --- | --- |
| Texto bruto | 0,194 | — |
| Normalizado | 0,238 | +22,7% |
| Normalizado + stemming leve (light8) | 0,376 | +93,8% |

Duas ressalvas. Isso é recuperação por palavras-chave de 2002 sobre notícias, não busca por embeddings. E o maior ganho veio do stemming leve (remoção de prefixos como و e ال e de sufixos comuns), que é uma etapa separada da normalização. O `ArabicAnalyzer` do Lucene e o analyzer `arabic` do Elasticsearch aplicam os dois: um normalizador e depois um stemmer leve.

## O que normalizar, e quanto custa cada regra?

| Regra | Exemplo | Índice de busca | Risco |
| --- | --- | --- | --- |
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | Sim, sempre primeiro | Também reescreve caracteres de compatibilidade de outros alfabetos |
| Remover marcas invisíveis | zero-width joiners, RLM/LRM, BOM | Sim | Nenhum para o árabe; o ZWNJ importa em persa |
| Remover tashkeel | أَحْمَدُ → أحمد | Sim | Junta palavras que só se distinguem pelas vogais |
| Remover tatweel (ـ) | الـــمدينة → المدينة | Sim | Nenhum |
| Unificar alef | أ إ آ ٱ → ا | Sim | Junta alguns pares: سأل (perguntou) e سال (escorreu) |
| Alef maksura | ى → ي | Normalmente | Junta على (sobre) e علي (Ali) |
| Ta marbuta | ة → ه | Normalmente | Junta كتابة (escrita) e كتابه (o livro dele) |
| Suportes da hamza | ؤ ئ → ء | Opcional | Junta مسؤول e مسئول (bom), mas também algumas palavras distintas |
| Letras persas | ی → ي, ک → ك | Sim, se os usuários têm teclado persa | Nenhum para texto em árabe |
| Dígitos | ٢٠٢٦ e ۲۰۲۶ → 2026 | Sim | Nenhum; guarde o original para exibição |

A terceira coluna vale para a chave do índice e para a consulta. O texto que você armazena, exibe e passa ao modelo fica como foi escrito.

## Por que a normalização Unicode deve vir primeiro?

A mesma letra visível pode ser armazenada de jeitos diferentes. أ pode ser um único code point (U+0623) ou um alef simples seguido de uma hamza combinante (U+0627 U+0654). PDFs mais antigos e alguns teclados produzem formas de apresentação árabes (de U+FB50 a U+FEFF), como o lam-alef ﻻ num único caractere. Na [normalização Unicode](https://unicode.org/reports/tr15/), o NFC compõe a hamza sobre o alef, e o NFKC também desfaz formas de apresentação e ligaduras. Em Python, `unicodedata.normalize("NFKC", "ﻻ")` retorna لا, e `ﷲ` vira الله.

Rode isso antes de qualquer outra coisa. Senão, uma regex que substitui أ deixa passar a forma decomposta. Há uma segunda armadilha: o `dediac_ar` do CAMeL Tools remove os caracteres do seu `AR_DIAC_CHARSET` (de U+064B a U+0652 e U+0670). Esse conjunto deixa de fora as marcas combinantes de hamza e madda (de U+0653 a U+0655), então, em texto decomposto, elas sobrevivem à remoção de diacríticos. O NFKC as compõe antes.

O NFKC é um mapeamento de compatibilidade. Ele também altera caracteres fora do árabe, por exemplo letras latinas de largura total. Numa chave de busca, isso costuma ser o que você quer, e é mais um motivo para guardar o original ao lado.

## O que não normalizar?

-   **O texto que você exibe, cita ou reproduz.** Árabe normalizado parece escrito errado (المدينه). Guarde o original ao lado da chave.
-   **O que você envia ao LLM.** Os modelos leem hamza e tashkeel sem problema, e o texto exato mantém nomes e citações corretos. Remover o tashkeel economiza alguns tokens; veja quantos com o [contador de tokens para árabe](https://broadrouter.com/tools/arabic-token-counter/) antes de trocar precisão por isso.
-   **Textos em que as marcas carregam sentido:** Alcorão, hadith, poesia, livros infantis, tarefas de pronúncia e de diacritização (veja [como adicionar diacríticos com um LLM](https://broadrouter.com/pt/blog/arabic-diacritization-llm/)).
-   **Correção ortográfica ou gramatical:** normalizar antes apaga justamente os erros de hamza e taa marbuta que você quer corrigir; veja [correção gramatical e ortográfica do árabe com um LLM](https://broadrouter.com/pt/blog/arabic-grammar-spelling-correction-llm/).
-   **Identificadores.** Códigos de produto, e-mails, URLs e texto latino não podem passar pelas regras do árabe. Aplique a normalização só a campos em alfabeto árabe, ou só a tokens em árabe.
-   **Campos que as pessoas buscam de forma exata.** Para razões sociais ou campos parecidos com identificadores, indexe também uma cópia bruta, para que uma correspondência exata ainda possa aparecer em primeiro.

## Em que CAMeL Tools, PyArabic e Lucene diferem?

Elas não implementam as mesmas regras, e misturá-las gera um índice e consultas que nunca batem. Lemos a documentação e o código-fonte de cada biblioteca e rodamos o PyArabic 0.6.15:

| Função | O que ela faz de fato |
| --- | --- |
| CAMeL `normalize_unicode` | NFKC (ou NFC com `compatibility=False`); também expande ﷼ para ريال e ﷽ para a frase completa |
| CAMeL `normalize_alef_ar` | إ أ ٱ آ → ا |
| CAMeL `normalize_alef_maksura_ar` | ى → ي |
| CAMeL `normalize_teh_marbuta_ar` | ة → ه |
| CAMeL `dediac_ar` | Remove de U+064B a U+0652 e U+0670; mantém o tatweel |
| PyArabic `strip_tashkeel` | Remove todas as harakat, inclusive o shadda |
| PyArabic `strip_tatweel` | Remove ـ |
| PyArabic `normalize_alef` | Toda forma de alef **e o ى** → ا, então إلى vira الا |
| PyArabic `normalize_hamza` | O método padrão transforma toda forma de hamza em ء, inclusive أ, então أحمد vira ءحمد |
| Lucene `ArabicNormalizer` | Formas de alef com hamza → ا, ة → ه, ى → ي, remove harakat e tatweel |

As linhas do PyArabic surpreendem. A docstring de `normalize_alef` diz que o alef maksura é uma exceção, mas na 0.6.15 o conjunto `ALEFAT` inclui ى, e a função o transforma em ا. O `normalize_hamza` foi feito para matching que ignora a hamza, não para busca em geral. A ordem também importa: rode primeiro a normalização do alef, e aí o `normalize_hamza` só mexe em ؤ, ئ e ء, então مسؤول e مسئول viram ambos مسءول. O método `tasheel` dele gera مسوول e مسيول, que não batem entre si.

O filtro `arabic_normalization` do Elasticsearch usa o normalizador do Lucene, então um pipeline em Python que precisa bater com um índice do Elasticsearch deve copiar exatamente as regras do Lucene. Ou seja, ى → ي, não ى → ا.

## Como é um normalizador testado?

Esta função segue as escolhas do Lucene, acrescenta tratamento de Unicode, dígitos e letras persas e deixa as regras arriscadas configuráveis. Ela usa só a biblioteca padrão.

```python
import re
import unicodedata

DIACRITICS = re.compile("[ً-ٰٟ]")  # tashkeel, extra marks, superscript alef
INVISIBLE = re.compile("[​-‏‪-‮⁦-⁩﻿]")  # zero-width, bidi
ALEF = re.compile("[آأإٱ]")    # آ أ إ ٱ -> ا
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹", "0123456789" * 2)
FARSI = str.maketrans({"ی": "ي", "ک": "ك"})  # ی -> ي, ک -> ك

def normalize(text, *, alef=True, alef_maksura=True, ta_marbuta=True,
              hamza_seats=False, digits=True):
    text = unicodedata.normalize("NFKC", text)     # compose marks, unpack ligatures
    text = INVISIBLE.sub("", text)
    text = DIACRITICS.sub("", text).replace("ـ", "")   # tashkeel, tatweel
    text = text.translate(FARSI)
    if alef:
        text = ALEF.sub("ا", text)
    if alef_maksura:
        text = text.replace("ى", "ي")    # ى -> ي
    if ta_marbuta:
        text = text.replace("ة", "ه")    # ة -> ه
    if hamza_seats:
        text = re.sub("[ؤئ]", "ء", text)  # ؤ ئ -> ء
    if digits:
        text = text.translate(DIGITS)
    return text
```

O que ela retornou nas nossas strings de teste:

| Entrada | Saída | Observação |
| --- | --- | --- |
| أَحْمَدُ | احمد | Tashkeel e hamza removidos |
| الـــمدينة | المدينه | Tatweel e ta marbuta |
| إلى | الي | Alef e alef maksura |
| ا + U+0654 + مل | امل | Hamza decomposta composta e depois unificada |
| ﻻبد | لابد | Forma de apresentação desfeita |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | Dígitos arábico-índicos e persas |
| مسؤول / مسئول | Ambos مسءول com `hamza_seats=True` | Sem alteração por padrão |
| فارسی | فارسي | Ya persa |

Use-a em dois lugares: ao montar a chave do índice e ao ler uma consulta. Armazene `original` e `normalize(original)` lado a lado, busque no segundo e retorne o primeiro. O [normalizador de texto em árabe](https://broadrouter.com/tools/arabic-text-normalizer/) gratuito permite colar um texto e ver o efeito de cada regra antes de escolher as configurações.

## Como a normalização se encaixa em embeddings e RAG?

Um pipeline RAG costuma ter dois recuperadores: busca por palavras-chave (BM25) e [embeddings](https://broadrouter.com/pt/glossary/embeddings/). A normalização claramente ajuda o lado das palavras-chave. Para o lado dos embeddings, as evidências acima não valem: modelos de embedding são treinados com texto bruto, e muitos já colocam احمد e أحمد perto um do outro. Normalizar antes do embedding pode ajudar, não fazer diferença ou atrapalhar. Monte de 50 a 100 consultas reais com respostas conhecidas, rode-as com entrada bruta e normalizada e fique com a que tiver mais recall. O que você escolher, aplique de forma idêntica a documentos e consultas.

A normalização também reduz um pouco a contagem de tokens, porque diacríticos e tatweel são caracteres extras para o [tokenizador](https://broadrouter.com/pt/glossary/tokenizer/). As proporções medidas estão no [dataset de eficiência de tokenizadores](https://broadrouter.com/data/tokenizer-efficiency/) e em [tokens por palavra em árabe](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/). A mesma normalização é usada para avaliar com justiça o reconhecimento de fala; veja [WER em árabe explicado](https://broadrouter.com/pt/blog/arabic-asr-wer-explained/).

O arabizi (árabe em letras latinas) exige uma abordagem totalmente diferente: [como os LLMs lidam com arabizi](https://broadrouter.com/pt/blog/arabizi-llm-handling/).

## Onde a BroadNet Inference entra

A normalização roda no seu próprio código, então não precisa de API. A BroadNet Inference entra depois da recuperação. Ela não vende embeddings, então combine um recuperador e um provedor de embeddings da sua escolha com um modelo de chat da BroadNet para a etapa de resposta. O [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) e o DeepSeek V4.1 Flash aceitam 1.048.576 tokens de contexto, então você pode passar muitos trechos recuperados no árabe original, sem normalização. Para escolher um modelo pela qualidade em árabe, veja [como escolher um LLM para árabe](https://broadrouter.com/pt/blog/choosing-an-llm-for-arabic/). Se você só precisa de busca por palavras-chave, o analyzer `arabic` embutido do Elasticsearch pode ser tudo de que você precisa.

Ferramentas gratuitas sobre o tema (em inglês)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Hamza (letra árabe)](https://broadrouter.com/pt/glossary/hamza/)

Hamza (ء) é a letra árabe que representa a oclusiva glotal. Ela é escrita sozinha ou sobre um suporte: alef (أ إ), waw (ؤ) ou yeh (ئ), e آ junta alef e madda. Como o texto digitado é inconsistente com ela, buscadores e a avaliação de fala costumam reduzir as formas com alef a ا.

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Embeddings](https://broadrouter.com/pt/glossary/embeddings/)

Embeddings são listas de números de ponto flutuante (vetores) que um modelo produz para representar um texto, uma imagem ou outra entrada. Entradas com significado parecido recebem vetores próximos, então a distância entre vetores serve para ordenar resultados de busca, agrupar documentos ou encontrar itens relacionados.

[Normalização Unicode (Unicode normalization)](https://broadrouter.com/pt/glossary/unicode-normalization/)

Normalização Unicode é a conversão de texto para uma forma padrão, para que strings que parecem iguais usem os mesmos code points. As quatro formas são NFD, NFC, NFKD e NFKC; as formas K também reduzem caracteres de compatibilidade, como formas de apresentação árabes e ligaduras, a letras comuns.

[Diacríticos árabes (tashkeel)](https://broadrouter.com/pt/glossary/arabic-diacritics/)

Diacríticos árabes, ou tashkeel, são pequenas marcas escritas acima ou abaixo das letras para indicar vogais curtas, consoantes dobradas e a ausência de vogal. São opcionais: a maior parte do texto árabe, incluindo notícias, não as usa, então leitores e software deduzem as vogais pelo contexto.

[Normalização de texto árabe (Arabic text normalization)](https://broadrouter.com/pt/glossary/arabic-text-normalization/)

Normalização de texto árabe é a etapa que converte as variantes de grafia de uma mesma palavra em uma única forma antes da comparação: remove diacríticos e tatweel, unifica as formas de alef e muitas vezes troca ى por ي e ة por ه. Ela se aplica a chaves de busca e à avaliação, não ao texto exibido.

[Tā’ marbūṭa (ta marbuta, ة)](https://broadrouter.com/pt/glossary/taa-marbuta/)

Ta marbuta (ة, U+0629) é uma letra árabe que só aparece no fim da palavra, muitas vezes marcando substantivos e adjetivos femininos. Ela parece um heh (ه, U+0647) com dois pontos, por isso o texto digitado mistura as duas, e muitos normalizadores de busca convertem ة em ه.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

## Perguntas frequentes

### Devo remover o tashkeel (diacríticos) antes de indexar texto em árabe?

Para busca, sim: a maioria das consultas e dos textos modernos não tem diacríticos, então documentos com diacríticos deixariam de ser encontrados. Remova-os da chave do índice e da consulta, guarde o texto original para exibição e mantenha-os para Alcorão, poesia ou tarefas de pronúncia, em que eles carregam sentido.

### O ta marbuta (ة) deve ser normalizado para ha (ه)?

Normalmente sim, para busca, porque muita gente digita ه no fim da palavra. Mas isso junta alguns pares, como كتابة (escrita) e كتابه (o livro dele). Se essas colisões importam no seu domínio, mantenha o ة e teste as duas configurações.

### O que a normalização de árabe faz no Elasticsearch?

O filtro de token arabic\_normalization usa o ArabicNormalizer do Lucene: formas de alef com hamza viram alef simples, ta marbuta vira ha, alef maksura vira ya, e harakat e tatweel são removidos. O analyzer arabic embutido acrescenta stop words e um stemmer que remove artigos, conjunções, preposições e sufixos comuns colados à palavra.

### Normalizar o árabe ajuda a busca por embeddings?

Isso não está comprovado. Os ganhos medidos vêm da recuperação por palavras-chave. Modelos de embedding aprendem com texto bruto e muitas vezes já lidam com variantes de grafia, então monte um pequeno conjunto de consultas reais e compare a recall com e sem normalização antes de decidir.

### Devo normalizar o texto em árabe antes de enviá-lo a um LLM?

Em geral, não. Envie o texto original para que citações, nomes e referências fiquem exatos. Remover o tashkeel economiza alguns tokens, mas só faça isso quando a tarefa não precisar das marcas.

## Continue lendo

-   [RAG em árabe: normalização, chunking e retrieval que funcionam](https://broadrouter.com/pt/blog/arabic-rag-search/)
-   [Tokens por palavra em árabe vs inglês: por que o árabe custa mais](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/)
-   [Word error rate (WER) no ASR em árabe: o que é e como calcular](https://broadrouter.com/pt/blog/arabic-asr-wer-explained/)
-   [Arabizi e LLMs: como lidar com o franco-árabe e números como 3 e 7](https://broadrouter.com/pt/blog/arabizi-llm-handling/)
-   [Como escolher uma API de LLM para árabe: o que testar](https://broadrouter.com/pt/blog/choosing-an-llm-for-arabic/)
-   [Extrair entidades nomeadas em árabe com LLM: JSON, datas e checagens](https://broadrouter.com/pt/blog/arabic-named-entity-extraction-llm/)
-   [Diacríticos no árabe com um LLM: prompt, checagens e DER](https://broadrouter.com/pt/blog/arabic-diacritization-llm/)
-   [Correção gramatical e ortográfica do árabe com um LLM: passo a passo](https://broadrouter.com/pt/blog/arabic-grammar-spelling-correction-llm/)
-   [Atas de reuniões em árabe a partir de gravações: um pipeline de API](https://broadrouter.com/pt/blog/arabic-meeting-minutes-from-recordings/)
-   [OCR para árabe por API: Google, Azure, Textract, Mistral e LLMs](https://broadrouter.com/pt/blog/arabic-ocr-api-comparison/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-arabic-text-normalization-search&utm_content=page-cta) ·

**Fontes**

-   [Larkey, Ballesteros e Connell, Improving Stemming for Arabic Information Retrieval: Light Stemming and Co-occurrence Analysis, SIGIR 2002 (consultado em 2026-11-15)](https://ciir.cs.umass.edu/pubfiles/ir-249.pdf)
-   [Documentação do CAMeL Tools 1.6.0, camel\_tools.utils.normalize (consultado em 2026-11-15)](https://camel-tools.readthedocs.io/en/latest/api/utils/normalize.html)
-   [Código-fonte do CAMeL Tools, charsets.py: o AR\_DIAC\_CHARSET usado por dediac\_ar (consultado em 2026-11-15)](https://github.com/CAMeL-Lab/camel_tools/blob/master/camel_tools/utils/charsets.py)
-   [PyArabic 0.6.15 no GitHub, módulo araby (consultado em 2026-11-15)](https://github.com/linuxscout/pyarabic)
-   [Documentação do ArabicNormalizer do Apache Lucene 9.12 (consultado em 2026-11-15)](https://lucene.apache.org/core/9_12_0/analysis/common/org/apache/lucene/analysis/ar/ArabicNormalizer.html)
-   [Filtros de token de normalização do Elasticsearch: arabic\_normalization (consultado em 2026-11-15)](https://www.elastic.co/docs/reference/text-analysis/analysis-normalization-tokenfilter)
-   [Unicode Standard Annex #15, Unicode Normalization Forms (consultado em 2026-11-15)](https://unicode.org/reports/tr15/)
-   [Tabela de códigos Unicode do árabe, de U+0600 a U+06FF (consultado em 2026-11-15)](https://www.unicode.org/charts/PDF/U0600.pdf)
