

# Prepare dados de transcrição do TikTok para análise de conteúdo

Sim, você pode coletar legendas públicas do TikTok para análise quantitativa de conteúdo depois de validá-las. Análise quantitativa de conteúdo significa contar uma regra clara de conteúdo em um conjunto de vídeos que você definiu. Uma faixa de legenda é texto público já anexado a um vídeo. Neste artigo, transcrição significa esse texto de legenda. Não significa uma nova cópia de cada palavra falada. Validar significa comparar a legenda com o vídeo você mesmo. O texto retornado é dado de legenda. Não é um registro completo da fala, das imagens ou de cada publicação do TikTok.

Uma pergunta pública de pesquisa pergunta como coletar transcrições do TikTok para um estudo. Também pergunta como conferir a precisão e como analisar o texto no R. R é um programa para tabelas e contagens. A pergunta mostra uma necessidade. Ela não prova que este método é válido. Ela não mostra quantos estudos precisam dele. Veja a [pergunta pública sobre transcrições do TikTok](https://www.reddit.com/r/CompSocial/comments/1h1zijh/help_needed_scraping_tiktok_video_transcripts_for/).

Você coleta linhas com um Actor. Um Actor é um programa hospedado de coleta de dados. Hospedado significa que ele roda como um serviço, não como um arquivo no seu computador. Este Actor é o [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper). Uma Task é um preset salvo de entrada. Um preset é um conjunto armazenado de escolhas de entrada. A Task atual é [TikTok Transcript Dataset for Content Analysis](https://apify.com/chronometrica/tiktok-transcript-scraper/examples/tiktok-transcript-content-analysis-dataset). O Actor coleta as linhas de origem. Você faz a codificação e as contagens. Uma Task pública é só uma entrada inicial. Ela não significa que a análise roda sozinha.

## O que o coletor atual retorna

Estes fatos públicos foram conferidos em 2026-10-13. A versão atual é 0.1.36. Cada execução aceita de 1 a 100 alvos públicos conhecidos em `startUrls`. Um alvo pode ser uma URL de vídeo, um link curto ou um ID numérico de vídeo. O Actor não pesquisa um perfil, uma palavra-chave nem uma página de som. Você já precisa conhecer os vídeos.

`preferredLanguages` é uma lista ordenada de idiomas de legenda pública. O Actor escolhe a primeira faixa pública correspondente. Uma lista vazia usa a primeira faixa pública. Ele não traduz texto. Ele não cria texto a partir de som que não tem legenda. Ele não coleta comentários. Ele não atribui códigos de conteúdo.

A entrada salva da Task é:

```json
{"startUrls": ["https://www.tiktok.com/@hankgreen1/video/7047596209028074758"], "preferredLanguages": []}
```

O que o coletor atual retorna

Substitua essa amostra pelos seus próprios vídeos públicos conhecidos. Para um piloto de um vídeo, coloque uma URL em `startUrls`. Se o inglês for o idioma do seu estudo, defina `preferredLanguages` como `["en"]`. Se o estudo usar outro idioma, escreva essa regra de idioma e use o código dele. Não copie `["en"]` para um estudo de outro idioma. Uma lista vazia pode retornar alguma outra faixa pública.

Uma linha do conjunto de dados representa cada entrada enviada. Uma entrada que falhou ainda recebe uma linha. Guarde essa linha. Ela é evidência da tentativa. Estes campos são exatos: `inputIndex`, `inputUrl`, `videoId`, `videoUrl`, `authorHandle`, `durationSeconds`, `languageCode`, `text`, `segments`, `status`, `statusReason`, `isBillable` e `scrapedAt`. Cada segmento tem `startSeconds`, `endSeconds` e `text`. Os tempos do TikTok usam essas duas chaves. Use `startSeconds` e `endSeconds` como foram retornados. Guarde cada `videoId` como texto, não como número. Um ID longo pode mudar se um programa o armazenar como número.

`status` pode ser `succeeded`, `no_public_captions`, `language_unavailable`, `duplicate_input`, `not_tiktok`, `invalid_input`, `unsupported_url`, `video_unavailable`, `not_public` ou `blocked_or_challenged`. Falhas de extração e falhas de legenda também podem ocorrer. O sucesso exige texto que não esteja vazio. Uma transcrição nula ou vazia com um status de falha não indica que o vídeo não tem fala. O vídeo ainda pode ter fala. Você só sabe que nenhuma legenda utilizável voltou.

`isBillable` é verdadeiro só para um resultado bem-sucedido de transcrição nativa. O nome do campo usa um b minúsculo. As outras linhas permanecem nos dados como evidência. `isBillable` não descreve a execução inteira. Uma execução pode misturar linhas verdadeiras e falsas. Não chame a execução inteira de gratuita.

O registro de totais da execução usa estes nomes exatos: `inputsReceived`, `resultRows`, `billableTranscriptRows`, `nonBillableResultRows`, `duplicateVideosSkipped` e `statusCounts`. Esse registro permite conferir a execução. Ele não mostra que os seus vídeos representam todos os criadores.

Uma conferência de um vídeo em 2026-10-13 usou a amostra salva. A linha teve sucesso. O ID do vídeo foi o ID pedido, `7047596209028074758`. O código de idioma foi `eng-US`. Um código como `eng-US` é um rótulo regional de legenda. Ele significa inglês com uma etiqueta de região dos Estados Unidos. Não é uma tradução. O texto não estava vazio. A linha tinha 12 segmentos. O tempo dos segmentos tinha a forma `startSeconds` e `endSeconds`. Nenhuma palavra de legenda desse vídeo é repetida aqui. Essa conferência prova um caminho de legenda pública nessa única fonte. Ela não prova palavras perfeitas. Ela não prova que todo vídeo tem sucesso. Ela não prova que o seu código de conteúdo é válido. O seu próprio piloto ainda é necessário.

## Oito ações

1. Defina a pergunta, o código e a amostra

Escreva uma pergunta de pesquisa. Escreva um código de conteúdo que você possa contar. Um código de conteúdo é a característica que você marca como presente ou ausente. Escolha URLs de vídeo conhecidas sob uma regra que você possa declarar. Declare o período, o idioma e quais criadores fazem parte do estudo antes de coletar.

Um registro de amostragem é a lista de cada vídeo que você selecionou. Preencha esse registro antes de olhar as legendas. Não selecione vídeos só porque existe uma legenda. Se você guardar só vídeos com legenda, você mudou a amostra. Vídeos sem legenda sairiam da amostra em vez de aparecer como ausentes.

1. Declare a unidade de contagem

Escolha a unidade que você vai contar. A unidade pode ser um vídeo, um segmento de legenda ou uma passagem que você define. Nestes passos, a unidade contada é o vídeo. Um segmento é um trecho cronometrado de texto de legenda. Os segmentos são evidência do vídeo. Eles não são vídeos extras.

Três segmentos com o mesmo código ainda contam como um vídeo. Escreva essa regra antes da execução. Guarde a URL de entrada, o `videoId` retornado e a sua própria `selected_video_key`. A chave do estudo é sua. Ela permanece a mesma mesmo se a forma da URL mudar.

1. Teste um vídeo selecionado

Execute um vídeo selecionado antes de qualquer lote. Isto é um piloto. Um piloto é um teste pequeno do caminho inteiro. Inspecione `status`, `videoId`, `languageCode` e `text`. O texto precisa não estar vazio para um sucesso. Se o idioma do estudo for inglês, defina `preferredLanguages` como `["en"]` neste piloto.

Depois, [compare uma passagem curta com o áudio](/pt-BR/articles/auditoria-de-palavras-de-legendas-do-tiktok/). Olhe também a imagem na tela. Anote palavras omitidas, palavras extras e palavras erradas. Uma linha bem-sucedida não prova que as palavras estão corretas. A conferência de 12 segmentos acima só mostra que o caminho público pode retornar uma legenda. Ela não é a sua validação.

1. Execute a lista limitada e reconcilie-a

Envie só as suas URLs conhecidas, até 100 em uma execução. Uma lista selecionada mais longa precisa de outra execução. Associe cada entrada enviada a uma linha de resultado. Use `inputIndex`, `inputUrl` e `videoId`. Confira se essas linhas correspondem ao registro de totais da execução.

Confira `inputsReceived`, `resultRows`, `billableTranscriptRows`, `nonBillableResultRows`, `duplicateVideosSkipped` e `statusCounts`. Guarde duplicatas nas notas e conte esse vídeo uma vez. Guarde legendas ausentes no registro, mas fora do conjunto de sucesso. Faça o mesmo com falhas de acesso à fonte. Esses status incluem `video_unavailable`, `not_public`, `blocked_or_challenged`, `unsupported_url`, `not_tiktok` e `invalid_input`.

Nunca codifique texto vazio que falhou como "código ausente". Texto vazio significa que você não observou o código. Não significa que o código está ausente.

1. Faça uma tabela de vídeos e uma tabela de segmentos

Faça uma linha por vídeo selecionado. Use estas colunas: `selected_video_key`, `videoId`, `videoUrl`, `languageCode`, `caption_status`, `caption_validated`, `study_eligible` e `exclusion_reason`. `study_eligible` registra se o vídeo pode entrar na contagem. Não é o código de conteúdo. `caption_validated` registra se você conferiu a legenda em relação ao vídeo.

Use `unknown` quando você não pôde conferir a legenda. Não escreva `caption_validated` como no quando o estado verdadeiro é desconhecido. Uma linha que falhou não foi validada. Uma revisão não terminada também não foi validada.

Guarde os segmentos em uma segunda tabela. Use a chave do vídeo, `startSeconds`, `endSeconds`, `text` e uma observação de origem. Um array de segmentos dentro de uma célula de planilha é uma exportação ruim. CSV é uma tabela de texto plana. Uma lista aninhada não cabe nessa forma plana de um modo seguro. Exporte JSON primeiro. JSON é um formato de texto que pode guardar uma lista dentro de um item. Depois, achate de propósito. Achatar significa fazer uma linha simples por segmento. Repita a chave do vídeo em cada linha de segmento. Não divida o texto nas vírgulas. Frases contêm vírgulas. Deixe o texto bruto da legenda sem mudança. Coloque cada código em colunas novas.

1. Escreva uma regra pequena de codificação e teste-a na ficção

Os exemplos deste passo em diante são ficção. Eles não são saída do Actor. Não cole estes IDs em uma entrada real. As URLs de vídeo deles são desconhecidas.

Escreva uma regra curta e dê uma versão a ela. Para uma regra simples de palavra exata, defina a palavra, a caixa das letras e o limite da palavra. Um limite de palavra impede que uma palavra curta corresponda dentro de uma palavra mais longa. Revise você mesmo os usos ambíguos. Uma regra de palavra-chave só encontra esse padrão. Ela não prova o que a pessoa falante quis dizer. Uma mensagem transmitida só por imagens pode entrar em conflito com as palavras. O sarcasmo também pode discordar das palavras. Esses casos precisam de uma pessoa para codificá-los.

O código fictício aqui é uma instrução explícita para medir água. A versão v1 da regra marca o código 1 quando o texto validado da legenda dá essa instrução. A palavra inteira "measure" conta em qualquer caixa de letras. A palavra "measurement" é uma palavra diferente. Revise-a. Não a marque só pela regra de palavra-chave. O código 0 só é permitido em uma legenda validada que não tem a instrução. Caso contrário, o código permanece desconhecido.

1. Confira um conjunto piloto e depois importe-o no R

Codifique um conjunto piloto pequeno antes de um estudo grande. Duas pessoas podem codificá-lo separadas uma da outra. Ou você pode codificá-lo de novo mais tarde e comparar. Guarde `code`, `code_version`, `coder`, `decision_note` e um timestamp. O timestamp registra quando a decisão foi feita. Guarde o texto bruto na própria coluna.

O R pode ler um CSV plano. Diga ao R que as colunas de ID são texto. Não deixe o R adivinhar um ID numérico. O trecho abaixo usa só o R base. Ele usa as linhas fictícias. Ele não adiciona um pacote. Ele não é um padrão de pesquisa testado. Aqui, `denom` é o denominador. O denominador é por quantos vídeos elegíveis você divide. `NA` significa não disponível. Este exemplo usa `NA` para um código desconhecido.

```r
videos <- data.frame(
  videoId = c("video-v1", "video-v2", "video-v3", "video-v4", "video-v5"),
  study_eligible = c("yes", "yes", "no", "no", "no"),
  code = c(1, 0, NA, NA, NA),
  stringsAsFactors = FALSE
)
stopifnot(is.character(videos[["videoId"]]))
eligible <- videos[["study_eligible"]] == "yes"
stopifnot(!any(is.na(videos[["code"]][eligible])))
code_count <- sum(videos[["code"]][eligible])
denom <- sum(eligible)
share <- code_count / denom
```

Oito ações

`code_count` é 1. `denom` é 2. `share` é 0.5. Os valores `NA` são códigos desconhecidos. Eles não são zeros. A linha `stopifnot` para o script se um vídeo elegível tiver um código desconhecido.

Quando você exportar um CSV real, mantenha a mesma conferência de texto:

```r
videos_from_csv <- read.csv(
  "video_table.csv",
  stringsAsFactors = FALSE,
  colClasses = c(videoId = "character")
)
stopifnot(is.character(videos_from_csv[["videoId"]]))
```

Oito ações

Você também pode testar a regra fictícia de palavra no R base:

```r
raw_text <- "I measure the water before I pour it"
hit <- grepl("\\bmeasure\\b", raw_text, ignore.case = TRUE)
ambiguous <- grepl("\\bmeasure\\b", "measurement", ignore.case = TRUE)
```

Oito ações

`hit` é TRUE. `ambiguous` é FALSE. O segundo resultado é o motivo de uma palavra mais longa precisar de uma regra de revisão humana, não de uma correspondência silenciosa.

1. Relate a contagem com o registro completo de resultados

Use só vídeos elegíveis como denominador da proporção do código. Elegível significa `succeeded`, texto não vazio e `caption_validated` yes. Relate cada resultado de vídeo selecionado ao lado dessa proporção. Os leitores precisam ver falhas e linhas não terminadas. Limite o achado aos vídeos que você selecionou e observou. Não o declare como um resultado para todos os criadores. Não o declare como um resultado para todo discurso político.

Legendas ausentes podem mudar uma conclusão. Este artigo para no registro. Ele não ensina [até onde essas linhas ausentes podem mover um resultado](/pt-BR/articles/como-legendas-ausentes-do-tiktok-alteram-a-amostra/).

## Contagem fictícia de cinco vídeos

A mesma ficção continua aqui. V1 a V5 são rótulos de estudo inventados. Os valores de `videoId` são rótulos de texto inventados. Eles não são IDs reais do TikTok. `videoUrl` é desconhecido em cada linha. Não envie estes rótulos ao Actor. Um `languageCode` real pode ser um valor regional, como `eng-US`. Esta ficção usa `en` porque o idioma declarado do estudo é inglês. Nas tabelas, unknown é o valor do estudo. No exemplo em R, `NA` guarda esse mesmo desconhecido. Não guarde unknown como 0.

O código declarado continua a ser a instrução explícita para medir água.

V1 é inglês. Teve sucesso. A legenda foi validada. O texto é "I measure the water before I pour it". Esse texto é uma instrução explícita para medir água. O código é 1.

V2 é inglês. Teve sucesso. A legenda foi validada. O texto é "I pour water into the tray". Ele manda alguém despejar. Ele não manda alguém medir. O código é 0.

V3 tem status `no_public_captions`. O texto está vazio. `languageCode` é desconhecido. Não invente um. `caption_validated` é unknown, não no. O código é desconhecido. Texto vazio não é código 0. Também não é prova de silêncio.

V4 tem status `language_unavailable`. O texto está vazio. `languageCode` é desconhecido. `caption_validated` é unknown. O código é desconhecido. Esta falha não é a mesma falha de V3. Mantenha os dois motivos separados.

V5 é inglês. Teve sucesso. Uma pessoa comparou a legenda com o áudio. A legenda omitiu a frase de medição. A validação não está terminada. `caption_validated` é unknown, não no. `study_eligible` é no. O código permanece desconhecido. Sucesso não é a mesma coisa que uma legenda confiável. Não transforme esta linha em código 0.

Um vídeo entra na proporção só quando `study_eligible` é yes. Essa decisão é separada do código. V1 e V2 são elegíveis porque a legenda teve sucesso, o texto não está vazio e uma pessoa a validou. V3 e V4 não são elegíveis porque a coleta falhou. V5 não é elegível porque a validação não está terminada. `isBillable` seria verdadeiro para V1, V2 e V5, porque esses resultados de transcrição tiveram sucesso. `isBillable` seria falso para V3 e V4. V5 é faturável e ainda não é elegível. O indicador faturável não decide a contagem do estudo.

Tabela de vídeos:

| selected_video_key | videoId | videoUrl | languageCode | caption_status | caption_validated | study_eligible | exclusion_reason |
| --- | --- | --- | --- | --- | --- | --- | --- |
| V1 | video-v1 | unknown | en | succeeded | yes | yes | none |
| V2 | video-v2 | unknown | en | succeeded | yes | yes | none |
| V3 | video-v3 | unknown | unknown | no_public_captions | unknown | no | sem legendas públicas; texto vazio não codificado |
| V4 | video-v4 | unknown | unknown | language_unavailable | unknown | no | idioma pedido ausente; texto vazio não codificado |
| V5 | video-v5 | unknown | en | succeeded | unknown | no | revisão do áudio não terminada; frase de medição omitida |

Tabela de códigos:

| selected_video_key | code | code_version | coder | decision_note | timestamp |
| --- | --- | --- | --- | --- | --- |
| V1 | 1 | v1 | coder-a | instrução explícita para medir água | example-only |
| V2 | 0 | v1 | coder-a | só instrução de despejar; instrução de medir ausente | example-only |
| V3 | unknown | v1 | coder-a | legenda falhou; código não observado | example-only |
| V4 | unknown | v1 | coder-a | legenda falhou; código não observado | example-only |
| V5 | unknown | v1 | coder-a | legenda não validada; código não observado | example-only |

Tabela de segmentos:

| selected_video_key | startSeconds | endSeconds | text | source_observation |
| --- | --- | --- | --- | --- |
| V1 | 0.5 | 2.5 | I measure the water before I pour it | evidência de legenda validada para o código 1 |
| V1 | unknown | unknown | unknown | segundo segmento de medição; só evidência extra; tempos não definidos aqui |
| V2 | unknown | unknown | I pour water into the tray | evidência de legenda validada para o código 0 |
| V5 | unknown | unknown | unknown | a legenda omitiu uma frase falada de medição; palavras não definidas aqui |

V3 e V4 não têm linhas de segmento. O texto do resultado deles está vazio. Não adicione um segmento em 0 segundos. Zero pareceria um tempo real. O tempo ausente permanece desconhecido.

O primeiro segmento de V1 termina em 2.5 segundos e começa em 0.5 segundos. 2.5 menos 0.5 é 2.0 segundos. Essa duração usa `endSeconds` e `startSeconds`. O segundo segmento de V1 também sustenta o código de medição. Ele não cria um segundo vídeo. V1 continua um vídeo codificado. A unidade contada é o vídeo.

Vídeos validados elegíveis: 2. Vídeos com código 1: 1. 1 / 2 = 0.5, o que é 50 por cento. O registro selecionado ainda tem 5 vídeos. 1 / 5 = 0.2, o que é 20 por cento. Não relate 20 por cento. V3, V4 e V5 não foram verificados como código 0. Desconhecido não é zero.

Contagens de resultado para os cinco vídeos selecionados: 2 validados e elegíveis, 2 com falha e 1 com validação não terminada. As duas falhas têm status diferentes. Uma é `no_public_captions`. A outra é `language_unavailable`.

Suponha que você enviou estas cinco entradas uma vez. Suponha que não houve duplicatas. O registro de totais esperado abaixo resulta dos cálculos desta ficção. Ele não é um recibo real. `inputsReceived` seria 5. `resultRows` seria 5. `billableTranscriptRows` seria 3. `nonBillableResultRows` seria 2. `duplicateVideosSkipped` seria 0. `statusCounts` mostraria `succeeded` 3, `no_public_captions` 1 e `language_unavailable` 1. A sua execução real precisa ser conferida com o registro de totais da execução que você de fato recebe.

Este exemplo mostra que segmentos extras não adicionam vídeos. Ele também mostra o denominador elegível. Ele não mostra um conjunto real de vídeos. Ele não mostra uma taxa de precisão de legenda. Ele não mostra um efeito além destas linhas inventadas.

Uma forma JSON plana para o segmento conhecido de V1 é:

```json
{
  "videoId": "video-v1",
  "segments": [
    {
      "startSeconds": 0.5,
      "endSeconds": 2.5,
      "text": "I measure the water before I pour it"
    }
  ]
}
```

Contagem fictícia de cinco vídeos

Esse objeto é ficção para o passo de achatar. Depois de achatar, a tabela de segmentos acima é a cópia de codificação. A tabela de vídeos permanece a cópia de contagem.

## Próxima ação

Valide um vídeo público selecionado antes de coletar a lista completa. Confira a entrada, a linha de status e o registro de codificação. Use o Actor [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper) e a Task [TikTok Transcript Dataset for Content Analysis](https://apify.com/chronometrica/tiktok-transcript-scraper/examples/tiktok-transcript-content-analysis-dataset). Substitua o vídeo de amostra por uma URL pública conhecida sua.

## Fontes e leituras adicionais

- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
- [TikTok Transcript Dataset for Content Analysis](https://apify.com/chronometrica/tiktok-transcript-scraper/examples/tiktok-transcript-content-analysis-dataset)
- [Pergunta pública sobre transcrições de vídeo do TikTok](https://www.reddit.com/r/CompSocial/comments/1h1zijh/help_needed_scraping_tiktok_video_transcripts_for/)