Social BrowserProfiles, IA e automação

User Scripts · Aprenda alterando páginas reais

Faça os sites funcionarem um pouco mais como você deseja.

Um User Script é um pequeno trecho de código executado em páginas da web correspondentes. Comece com algumas linhas, faça uma alteração útil e aprenda JavaScript somente quando necessário.

Adequado para iniciantesPratique em todas as aulasJavaScript, CSS e HTMLIntegrado em Social BrowserFunciona com automação de IA
Nunca escreveu um roteiro?Comece com a Lição 1. Explicamos o JavaScript mínimo que você precisa.
Já usa scripts no estilo Tampermonkey?Vá para metadados, correspondência, escopo e Social Browser Profiles.
Quer fluxos de trabalho completos?Use User Scripts junto com Automation Studio e workflows de IA via MCP AI.

Exemplos de trabalho

Copie um pequeno script. Veja a mudança de página.

Comece com melhorias de página inofensivas. Cada exemplo é intencionalmente pequeno para que você possa entender cada linha antes de usá-la.

Aprenda como criar um script →
Iniciante · JavaScript

Destaque um valor importante

Encontre um elemento e torne-o mais fácil de perceber.

Exemplo
const total = document.querySelector('.total');if (total) { total.style.background = '#fff3a6'; total.style.fontWeight = '700';}

Use-o para: painéis, totais, rótulos de status ou páginas de controle de qualidade que você controla.

Aprenda o JavaScript
Iniciante · CSS

Ocultar uma barra lateral que distraia

Às vezes, uma regra CSS é tudo que você precisa.

Exemplo CSS
.promo-sidebar { display: none !important;}

Use-o para: painéis internos mais limpos ou páginas que você revisa repetidamente.

Aprenda CSS e HTML
Construtor · JavaScript

Adicione um botão Copiar ao lado de um valor

Crie um pequeno ajudante em vez de repetir as etapas de copiar/colar manualmente.

Exemplo
const value = document.querySelector('#order-id');if (value) { const button = document.createElement('button'); button.textContent = 'Copy'; button.onclick = () => navigator.clipboard.writeText(value.textContent.trim()); value.after(button);}

Use-o para: IDs, referências ou valores não confidenciais que você copia com frequência.

Aprenda eventos
React · Páginas dinâmicas

Aguarde o conteúdo que aparece mais tarde

As páginas modernas geralmente são renderizadas após o primeiro carregamento. Observe apenas o que você precisa.

Exemplo
const observer = new MutationObserver(() => { const result = document.querySelector('.result-ready'); if (!result) return; result.style.outline = '2px solid #4caf50'; observer.disconnect();});observer.observe(document.body, { childList: true, subtree: true });

Use-o para: Painéis SPA e widgets de páginas atrasadas.

Aprenda páginas dinâmicas
Integrar · Profiles

Use o mesmo auxiliar em Profiles separado

O script permanece reutilizável enquanto cada Profile mantém sua própria sessão do navegador e estado da página.

Mesmo roteiro→Profile A+ProfileB+Profile C
  1. Crie um pequeno script.
  2. Corresponda apenas ao site pretendido.
  3. Abra o site em teste diferente Profiles.
  4. Confirme se o auxiliar se comporta corretamente em cada contexto.
Aprenda scripts + Profiles
Avançado · Escolha a ferramenta

User Script + Automation Studio

Mantenha ajudantes de página persistentes em um User Script e orquestração de várias etapas em Automation Studio.

User Script+Fluxo de trabalho→Processo reutilizável
  1. User Script melhora a página correspondente.
  2. Workflow executa etapas ordenadas do navegador.
  3. A automação seleciona Profiles e política de execução.
  4. A tarefa decide quando executar.
Aprenda quando combiná-los
Antes de executar o código da Internet: leia-o, entenda quais páginas ele corresponde, verifique o comportamento do armazenamento/rede e teste-o em um Profile controlado. Esses exemplos evitam intencionalmente senhas, cookies e dados de sessão.

Biblioteca de exemplos GM API

Receitas GM úteis que você pode copiar, ler e adaptar.

Cada exemplo é intencionalmente pequeno. Comece com um problema, copie o script, leia cada linha e altere apenas os seletores, URLs ou rótulos que você entende.

Abra o guia GM API completo →
Lembra de uma configuração? ArmazenamentoLeia outra origem? RedeAdicionar um ajudante de página? Ajudantes de páginaAdicionar uma ação do usuário? Comandos de menuAlertar o usuário? NotificaçõesSalvar um arquivo? Downloads
Iniciante · Armazenamento

Lembre-se de uma preferência de modo compacto

Salve uma preferência de IU inofensiva e restaure-a no próximo carregamento da página.

JavaScript · preferência persistente
// ==UserScript==// @name Compact mode preference// @match https://example.com/*// @grant GM_getValue// @grant GM_setValue// ==/UserScript== const compact = GM_getValue('compact', false);document.documentElement.classList.toggle('my-compact-mode', compact); const button = document.createElement('button');button.textContent = compact ? 'Use normal mode' : 'Use compact mode';button.addEventListener('click', () => { GM_setValue('compact', !compact); location.reload();});document.body.prepend(button);
Aprenda armazenamento GM
Construtor · Ajudante de página

Adicione um pequeno painel auxiliar

Injete CSS e um elemento auxiliar sem substituir o layout do site.

JavaScript · GM_addStyle + GM_addElement
// @grant GM_addStyle// @grant GM_addElement GM_addStyle(` .sb-helper { position: fixed; right: 16px; bottom: 16px; padding: 10px 12px; background: #111827; color: white; border-radius: 8px; z-index: 2147483647; }`); GM_addElement(document.body, 'div', { class: 'sb-helper', textContent: 'Page helper is active'});
Aprenda ajudantes de página
Construtor · Rede

Leia JSON de um API permitido

Use uma solicitação privilegiada quando os dados necessários não fizerem parte da página atual.

JavaScript · GM_xmlhttpRequest
// ==UserScript==// @name API status helper// @match https://example.com/*// @grant GM_xmlhttpRequest// @connect api.example.com// ==/UserScript== GM_xmlhttpRequest({ method: 'GET', url: 'https://api.example.com/status', responseType: 'json', onload(response) { console.log('Status:', response.response?.status); }, onerror(error) { console.error('Request failed:', error); }});
Aprenda solicitações privilegiadas
Reagir · Área de transferência

Copie uma referência de página com segurança

Copie um valor não confidencial após um clique explícito do usuário.

JavaScript · GM_setClipboard
// @grant GM_setClipboard const reference = document.querySelector('#reference-id');if (reference) { const copyButton = document.createElement('button'); copyButton.textContent = 'Copy reference'; copyButton.addEventListener('click', () => { GM_setClipboard(reference.textContent.trim(), 'text'); copyButton.textContent = 'Copied'; }); reference.after(copyButton);}
Aprenda o acesso à área de transferência
Reagir · Comando de menu

Adicione uma ação de script ao menu User Script

Mantenha as ações opcionais fora da IU da página e execute-as somente quando o usuário solicitar.

JavaScript · GM_registerMenuCommand
// @grant GM_registerMenuCommand GM_registerMenuCommand('Highlight overdue rows', () => { document.querySelectorAll('[data-status="overdue"]').forEach(row => { row.style.outline = '2px solid currentColor'; });});
Aprenda comandos de menu
Integrar · Notificação

Notificar quando uma tarefa de página longa estiver pronta

Mostre uma notificação do navegador apenas para um evento significativo.

JavaScript · GM_notificação
// @grant GM_notification function notifyReady(label) { GM_notification({ title: 'Social Browser User Script', text: `${label} is ready to review`, timeout: 5000 });} // Call this only after your script detects the result.notifyReady('The report');
Aprenda notificações
Integrar · Guias

Abra uma página relacionada em uma guia em segundo plano

Abra informações de suporte sem substituir a página que o usuário está revisando.

JavaScript · GM_openInTab
// @grant GM_openInTab const helpButton = document.createElement('button');helpButton.textContent = 'Open details';helpButton.addEventListener('click', () => { GM_openInTab('https://example.com/details', { active: false, insert: true });});document.body.prepend(helpButton);
Guia Aprender APIs
Avançado · Estado da guia

Lembre-se do progresso de uma guia do navegador

Mantenha o estado temporário do script anexado à guia atual em vez do armazenamento global.

JavaScript · GM_getTab + GM_saveTab
// @grant GM_getTab// @grant GM_saveTab GM_getTab(tabState => { tabState.reviewStep = (tabState.reviewStep || 0) + 1; GM_saveTab(tabState); console.log('Review step:', tabState.reviewStep);});
Aprenda o estado por guia
Avançado · Baixar

Baixe um arquivo de relatório

Use o recurso de download para um arquivo que o usuário solicitou intencionalmente ao script para salvar.

JavaScript · GM_download
// @grant GM_download GM_download({ url: 'https://example.com/reports/today.csv', name: 'today-report.csv', saveAs: true, onload() { console.log('Download completed'); }, onerror(error) { console.error('Download failed:', error); }});
Aprenda downloads
Avançado · Recurso

Agrupe um pequeno recurso de texto com um script

Faça referência a um recurso declarado em vez de codificar um grande ativo de texto reutilizável.

JavaScript · @resource + GM_getResourceText
// ==UserScript==// @name Template resource example// @match https://example.com/*// @resource helperTemplate https://example.com/assets/helper.html// @grant GM_getResourceText// ==/UserScript== const template = GM_getResourceText('helperTemplate');if (template) { const box = document.createElement('div'); box.innerHTML = template; document.body.append(box);}
Aprenda recursos
Antes de executar o código copiadoLeia, restrinja seu @match regras, revise cada @grant and @connecte teste-o primeiro em um Profile seguro.
Curso User ScriptsVisão geral do curso
Escolha uma lição ou inicie o curso guiado.
Iniciante · Lição 1

O que realmente é um User Script

Hora 5 minutosObjetivo Entenda o que User Scripts pode mudar

Um User Script é JavaScript que o navegador executa para você em páginas que correspondem às regras que você escolher. Ele pode fazer pequenas alterações em um site após a página ser aberta: destacar informações, adicionar um atalho, ocultar a desordem, auxiliar um formulário repetido ou reagir a eventos da página.

Sem um roteiro

  1. Abra a página.
  2. Faça o mesmo pequeno ajuste.
  3. Repita na próxima visita.

Com um User Script

  1. Crie a regra uma vez.
  2. Limite-o às páginas certas.
  3. Deixe-o ser executado automaticamente quando essas páginas forem abertas.

Por que User Scripts é útil dentro de Social Browser

Social Browser combina User Scripts com o navegador persistente Profiles. Um Profile pode manter sua própria sessão, armazenamento, configurações e scripts, portanto, uma pequena personalização pode ficar próxima ao contexto do navegador onde você realmente o utiliza.

Importante: um User Script executa código dentro de páginas da web. Instale scripts apenas de fontes que você conhece e confia. Um script útil deve ser fácil de ler, limitado às páginas necessárias e fácil de desativar.
Iniciante · Lição 2

Crie seu primeiro User Script

Hora 5–10 minutosObjetivo Execute um pequeno script e veja uma mudança de página

Comece com algo inofensivo e visível. O objetivo é provar o fluxo completo: criar → salvar → habilitar → abrir uma página correspondente → ver o resultado.

1

Abra User Scripts

Abra o gerenciador User Script integrado em Social Browser e crie um novo script.

2

Dê um nome claro

Use um nome que diga o que o script faz, como Highlight Test Heading.

3

Escolha uma página de teste segura

Use uma página que você controla ou uma página inofensiva onde a alteração da exibição não enviará dados nem alterará uma conta.

4

Adicione algumas linhas de JavaScript

const heading = document.querySelector('h1');if (heading) heading.style.outline = '3px solid currentColor';
5

Salve e ative-o

Recarregue a página correspondente. Se o título tiver um esboço, seu primeiro script está funcionando.

Regra para iniciantes: um script, um resultado visível. Não comece copiando um script de 500 linhas que você não consegue explicar.
Iniciante · Lição 3

Faça o script ser executado apenas onde ele pertence

Hora 5 minutosObjetivo Use regras URL permitidas e excluídas com segurança

A correspondência de páginas é uma das habilidades mais importantes do User Script. Um script que deve personalizar um painel não precisa de permissão para ser executado em todos os sites que você visita.

1

Permitido URLs

Descreva as páginas onde o script é útil.

2

URLs excluído

Bloqueie páginas dentro da área onde o script deve permanecer inativo.

3

Teste os dois lados

Abra uma página correspondente e uma página não correspondente antes de confiar na regra.

Etapa 1 concluídaSe o seu script for executado apenas na página pretendida, você estará pronto para construir algo útil.
Construtor · Lição 4

O JavaScript que você realmente precisa primeiro

Hora 10 minutosObjetivo Ler e alterar elementos simples da página

Você não precisa de toda a linguagem JavaScript para tornar User Scripts útil. Comece com quatro ideias: encontrar um elemento, ler um valor, mudar algo e responder a um evento.

NecessidadeJavaScript simples
Encontre um elementodocument.querySelector('.price')
Leia seu textoelement.textContent
Alterar textoelement.textContent = 'Done'
Alterar um estiloelement.style.fontWeight = '700'
Reaja a um cliquebutton.addEventListener('click', handler)

Sempre verifique se um elemento existe antes de usá-lo. Os sites mudam e um elemento ausente não deve travar todo o script.

Construtor · Lição 5

Use JavaScript, CSS e HTML para diferentes trabalhos

Hora 8 minutosObjetivo Escolha a ferramenta mais simples para uma mudança de página
JS

JavaScript

Use-o para lógica, eventos, leitura de valores e mudança de comportamento.

CSS

CSS

Use-o para aparência: oculte, redimensione, destaque ou reorganize elementos visuais.

HTML

HTML

Use-o quando o script precisar de um pequeno painel auxiliar, rótulo ou controle.

Mantenha as alterações de página pequenas: adicionar uma caixa auxiliar é mais fácil de manter do que reconstruir a interface de um site dentro de um script.
Construtor · Lição 6

Use o gerenciador de scripts integrado

Hora 7 minutosObjetivo Crie, encontre, habilite e edite scripts com confiança

O Gerenciador de Scripts é onde os scripts reutilizáveis devem ficar organizados. Use nomes claros, mantenha os experimentos desativados separados dos scripts de trabalho e facilite a desativação de um script ao depurar uma página.

  • Crie e edite um script.
  • Pesquise ou identifique-o por um nome claro.
  • Ative ou desative-o sem excluí-lo.
  • Revise as regras JavaScript, CSS, HTML e URL juntas.
  • Mantenha os scripts experimentais visivelmente nomeados como testes.
Construtor · Lição 7

Importe scripts sem tratar a Internet como código confiável

Hora 8 minutosObjetivo Importe de um arquivo ou URL e revise antes de ativar

Social Browser pode criar scripts manualmente ou importá-los de um arquivo ou direcionar URL. Ele também pode reconhecer fluxos de instalação comuns do User Script. Importar é conveniente, mas conveniência não é o mesmo que confiança.

1

Conheça a fonte

Prefira o código que você escreveu, o de sua equipe ou uma fonte que você possa verificar.

2

Leia os metadados

Verifique o nome, correspondência com URLs e comportamento de execução.

3

Revise o código

Procure solicitações de rede inesperadas, ações ocultas de formulários, acesso ao armazenamento ou correspondência ampla de páginas.

4

Teste em um Profile seguro

Habilite-o em uma página controlada antes de usá-lo em uma sessão importante do navegador.

Construtor · Lição 8

Os metadados informam ao navegador como o script deve ser executado

Hora 8 minutosObjetivo Entenda as configurações em torno do código

Um User Script útil é mais do que JavaScript. Social Browser pode usar informações de script como título/nome, URLs permitido e excluído, visibilidade de menu, escopo de janela/quadro, execução automática e execução de estágio de pré-carregamento.

ConfiguraçãoPergunta que responde
Nome/títuloO que esse script faz?
Permitido URLsOnde ele pode funcionar?
URLs excluídoOnde não deve correr?
Escopo de janela/quadroQual contexto de documento deve recebê-lo?
Execução automáticaDeveria ser executado sem uma ação manual do menu?
Estágio de pré-carregamentoPrecisa começar mais cedo no carregamento da página?
Visibilidade do menuO usuário deve ser capaz de acioná-lo no menu de script?
Reagir · Lição 9

Reaja à página em vez de verificá-la constantemente

Hora 8 minutosObjetivo Use eventos DOM para interações simples

As páginas já produzem eventos: cliques, alterações de entrada, foco, navegação e muito mais. Ouvir o evento que você precisa geralmente é mais limpo do que executar um loop rápido que verifica a página inteira repetidamente.

const button = document.querySelector('#save');button?.addEventListener('click', () => { console.log('Save button clicked');});
Regra de desempenho: prefira um evento ou um observador limitado a um temporizador permanente de alta frequência.
Reagir · Lição 10

Lidar com páginas que mudam após serem carregadas

Hora 10 minutosObjetivo Trabalhar com elementos atrasados e renderizados novamente

Os sites modernos geralmente renderizam o conteúdo após o carregamento da primeira página. Se o seu elemento de destino ainda não existir, o script pode esperar por ele ou observar alterações em uma parte específica da página.

Evite longos atrasos arbitrários. Esperar cinco segundos em qualquer lugar pode ocultar o problema, mas torna os scripts lentos e pouco confiáveis. Espere pelo que você realmente precisa e pare de esperar depois de um limite sensato.
Reaja · Lição 11

Salve pequenas preferências, não segredos

Hora 7 minutosObjetivo Lembre-se de configurações de script inofensivas

Um script pode precisar lembrar uma preferência inofensiva, como se um painel auxiliar está recolhido ou qual modo de exibição você selecionou. O armazenamento do navegador pode ajudar, mas informações confidenciais de contas, senhas, segredos 2FA e material de sessão não devem ser armazenados casualmente em scripts.

Bons dados de preferência

  • Painel aberto/fechado.
  • Linhas por página.
  • Opção de exibição.

Trate como sensível

  • Senhas.
  • Segredos 2FA.
  • Material de sessão/cookie.
Reaja · Lição 12

Leia os dados da página primeiro; solicitar outros dados somente quando necessário

Hora 8 minutosObjetivo Mantenha o acesso aos dados simples e compreensível

Se a informação já estiver na página, leia-a no DOM. Se o seu script realmente precisar de outro recurso da web, as regras normais de rede do navegador ainda serão importantes. Mantenha as solicitações visíveis em seu código e evite enviar dados de páginas/contas para algum lugar que o usuário não esperava.

Regra simples: if the script sends data away from the page, a reviewer should be able to see exactly what is sent and why.
Integrar · Lição 13

User Scripts torna-se mais útil com Profiles persistente

Hora 8 minutosObjetivo Entenda o comportamento do script em contextos de navegador separados

Um Social Browser Profile mantém seu próprio contexto de navegador. Isso significa que você pode manter as sessões da conta e o estado da página separados enquanto reutiliza a mesma ideia de script quando apropriado. Teste um script no contexto Profile específico onde ele será executado.

Perfil→Página correspondente→User Script→Melhoria de página pequena

Não presuma que um script que funciona em um estado de site funcionará automaticamente em todos os Profile. Sessões diferentes podem mostrar diferentes layouts, permissões ou conteúdos.

Integrar · Lição 14

Quadros e tempo: execute no documento certo no momento certo

Hora 10 minutosObjetivo Escolha o escopo e o tempo de execução deliberadamente

Uma página pode conter o documento principal mais um ou mais quadros. Um script também pode precisar de execução automática normal ou de um estágio de pré-carregamento anterior. Essas opções resolvem problemas diferentes, portanto não altere todas quando faltar um elemento.

Escopo

Página principal ou frame?

Identifique qual documento realmente contém o elemento.

Tempo

Normal ou pré-carga?

Comece cedo somente quando o script realmente precisar afetar a inicialização.

Dinâmico

Renderizado mais tarde?

Se a página criar o elemento posteriormente, lide com o conteúdo dinâmico em vez de alterar o escopo às cegas.

Integrar · Lição 15

Depure um User Script sem adivinhar

Hora 10 minutosObjetivo Descubra se o problema é a correspondência, o tempo, o código ou o site
1

Confirme se o script está ativado

Não depure o código que está desabilitado no momento.

2

Confirme as correspondências URL

Verifique as regras permitidas e excluídas.

3

Adicione mensagens claras do console

Registrar quando o script for iniciado e antes da operação que você está testando.

4

Verifique o elemento de destino

Veja se ele já existe e se a página o renderizou novamente.

5

Desative o script e compare

Se o problema da página persistir após desativá-la, o script pode não ser a causa.

Etapa 4 concluídaAgora você pode criar, definir o escopo e depurar User Scripts normal dentro de Social Browser.
Avançado · Lição 16

Escreva scripts fáceis de confiar e manter

Hora 10 minutosObjetivo Reduza o acesso desnecessário e o comportamento oculto
  • Combine apenas as páginas que o script precisa.
  • Use nomes e comentários claros para comportamentos não óbvios.
  • Mantenha os destinos de rede visíveis no código.
  • Evite armazenar informações confidenciais da conta.
  • Pare observadores e cronômetros quando eles não forem mais necessários.
  • Não esconda efeitos colaterais importantes por trás de vagas funções auxiliares.
  • Teste as alterações em um Profile seguro antes de sessões importantes.
  • Mantenha uma maneira rápida de desativar o script.
Avançado · Lição 17

Receitas práticas User Script

Hora 15 minutosObjetivo Comece com pequenos padrões reutilizáveis
Receita 1 · Destaque valores importantesIniciante
  1. Combine uma página específica.
  2. Encontre os elementos de valor.
  3. Adicione uma classe ou estilo CSS.
  4. Não faça nada se os elementos estiverem faltando.
Receita 2 · Adicionar um atalho de páginaIniciante
  1. Crie um pequeno botão auxiliar.
  2. Insira-o próximo à área relevante.
  3. Ouça seu clique.
  4. Execute uma ação de página local.
Receita 3 · Limpe um painelIntermediário
  1. Oculte apenas a desordem visual claramente identificada.
  2. Mantenha os controles da página principal intactos.
  3. Salve uma preferência de exibição inofensiva, se for útil.
Receita 4 · Assistir uma forma repetidaIntermediário
  1. Detecte o formulário.
  2. Preencha apenas valores repetidos não confidenciais que o usuário espera.
  3. Deixe a decisão final de envio visível para o usuário, a menos que o fluxo de trabalho exija explicitamente automação.
Receita 5 · Aguarde conteúdo dinâmicoIntermediário
  1. Procure uma vez pelo elemento.
  2. Se estiver faltando, observe uma área pai estreita.
  3. Pare de observar depois que o elemento aparecer ou após um tempo limite.
Avançado · Lição 18

User Script, Automation Studio ou ambos?

Hora 8 minutosObjetivo Escolha a ferramenta mais simples para o trabalho
Eu quero…Comece com…
Alterar a aparência ou o comportamento de uma página correspondente sempre que eu a abrirUser Script
Adicione um pequeno auxiliar ou atalho de páginaUser Script
Execute um processo de navegador ordenado de várias etapasAutomation Studio Workflow
Execute o mesmo processo em Profiles ou de acordo com uma programaçãoAutomation Studio
Mantenha uma personalização de página útil enquanto uma automação Workflow é executadaUser Script + Automation Studio
Precisa de lógica de página personalizada dentro de um fluxo de trabalho maiorUse a combinação suportada mais simples e mantenha as responsabilidades claras
A boa arquitetura é chata: mantenha a personalização persistente da página em um User Script e a orquestração do fluxo de trabalho em Automation Studio. Não transforme um script gigante em um sistema de automação completo se o Studio já fornece o recurso de fluxo de trabalho.
Referência GM API

GM APIs em Social Browser — desde o primeiro uso até scripts avançados

Use isso quando página simples JavaScript não é suficienteObjetivo Use recursos de script no nível do navegador com segurança

GM APIs fornecem recursos User Script que a página normal JavaScript nem sempre possui, como armazenamento com escopo de script, solicitações de origem cruzada, notificações, downloads, acesso à área de transferência, recursos e comandos de menu de script. Em Social Browser, um explícito @grant script recebe apenas os recursos solicitados.

Navegue por categoria ou pesquise pelo nome API.

Comece pequeno: não adicione todos @grant linha “por precaução”. Peça apenas os APIs que o script realmente usa. Isso torna o script mais fácil de entender, revisar e confiar.

Comece aqui

How @grant funciona

Para novos scripts, declare todos os API privilegiados que você usa. Social Browser executa scripts com concessões explícitas em um mundo User Script isolado e conecta apenas os recursos solicitados. Um roteiro com @grant none funciona sem recursos de GM.

JavaScript · script mínimo concedido
// ==UserScript==// @name Remember display mode// @namespace https://example.com/my-scripts// @match https://example.com/*// @grant GM_getValue// @grant GM_setValue// ==/UserScript== const mode = GM_getValue('displayMode', 'compact');console.log('Saved mode:', mode); GM_setValue('displayMode', 'comfortable');

Clássico GM_* ou moderno GM.*?

Social Browser suporta os nomes clássicos familiares e seus modernos GM.* forms for the main GM capability set. The modern form is Promise-friendly, so use await. Escolha um estilo por script e mantenha a consistência.

Clássico
JavaScript
const theme = GM_getValue('theme', 'dark');GM_setValue('theme', 'light');
Moderno
JavaScript
const theme = await GM.getValue('theme', 'dark');await GM.setValue('theme', 'light');

GM_info / GM.info

Use informações de script quando precisar inspecionar o script atual, versão, concessões, correspondências ou informações de tempo de execução Social Browser. Não codifique o comportamento em torno de strings de versão, a menos que você realmente precise de lógica de compatibilidade.

JavaScript · inspecionar metadados de script
// @grant GM_info console.log('Script:', GM_info.script.name);console.log('Version:', GM_info.version);console.log('Handler:', GM_info.scriptHandler);console.log('Grants:', GM_info.scriptGrants);console.log('Matches:', GM_info.scriptMatches);

Armazenamento

Lembre-se de pequenos dados de script

O armazenamento GM tem como escopo User Script em vez de ser um armazenamento de página comum. É ideal para preferências, contadores e estados de script inofensivos. Não o use como um cofre casual para senhas, segredos 2FA, cookies ou material de sessão.

APIO que isso fazResultado típico
GM_getValue(key, defaultValue)Leia um valor salvo.O valor salvo ou seu padrão.
GM_setValue(key, value)Salve um valor.Atualiza o armazenamento com escopo de script.
GM_deleteValue(key)Remova um valor.A chave desaparece.
GM_listValues()Listar chaves salvas.Uma matriz de nomes de chaves.
GM_getValues(...)Leia vários valores juntos.Um objeto de valores.
GM_setValues(object)Salve vários valores juntos.Atualiza cada chave fornecida.
GM_deleteValues(keys)Exclua várias chaves.Remove os valores listados.
JavaScript · salvar preferências do usuário
// @grant GM_getValue// @grant GM_setValue// @grant GM_deleteValue const settings = GM_getValue('settings', { compact: true, rowsPerPage: 25}); settings.rowsPerPage = 50;GM_setValue('settings', settings); // Reset later if the user asks for defaults.// GM_deleteValue('settings');

Observe uma mudança de valor

GM_addValueChangeListener é útil quando o mesmo script está aberto em mais de um quadro ou guia. O retorno de chamada recebe (name, oldValue, newValue, remote). Em Social Browser, os eventos de alteração de valor podem sincronizar entre quadros/guias no mesmo Profile/sessão.

JavaScript · ouvinte de armazenamento
// @grant GM_addValueChangeListener// @grant GM_removeValueChangeListener const listenerId = GM_addValueChangeListener( 'displayMode', (name, oldValue, newValue, remote) => { console.log({ name, oldValue, newValue, remote }); }); // Remove it when you no longer need it.// GM_removeValueChangeListener(listenerId);

Ajudantes de página

Adicione estilos ou pequenos elementos

GM_addStyle(css) / GM.addStyle(css)

Use isto quando a personalização de uma página for principalmente visual. É mais limpo do que definir muitos element.style propriedades.

JavaScript · injetar CSS
// @grant GM_addStyle GM_addStyle(` .important-total { font-weight: 700; outline: 2px solid currentColor; padding: 4px 8px; }`);

GM_addElement(...) / GM.addElement(...)

Crie um pequeno elemento DOM e anexe-o com segurança. Você pode passar um elemento pai primeiro ou omiti-lo para usar o corpo da página.

JavaScript · adicionar um botão auxiliar
// @grant GM_addElement const panel = document.querySelector('#account-panel');if (panel) { GM_addElement(panel, 'button', { type: 'button', textContent: 'Copy account ID', className: 'my-copy-button', onclick() { const id = panel.querySelector('.account-id')?.textContent?.trim(); if (id) navigator.clipboard.writeText(id); } });}

Rede

Faça solicitações privilegiadas com GM_xmlhttpRequest

Página normal fetch() é controlado pelas regras normais do navegador/CORS da página. A solicitação GM de Social Browser API usa um canal de solicitação de processo de navegador dedicado. Antes de uma solicitação ser enviada, seu destino é verificado em relação ao script @connect regras.

O acesso à rede merece revisão. Mantenha os destinos estreitos e visíveis. Nunca envie dados de conta/página para um serviço que o usuário não esperaria.
JavaScript · Solicitação JSON
// ==UserScript==// @match https://app.example.com/*// @connect api.example.com// @grant GM_xmlhttpRequest// ==/UserScript== const response = await GM_xmlhttpRequest({ method: 'GET', url: 'https://api.example.com/status', responseType: 'json', timeout: 10000, headers: { Accept: 'application/json' }}); console.log(response.status, response.response);

Retornos de chamada e aborto

A solicitação API oferece suporte a retornos de chamada de solicitação comuns e retorna um identificador que pode ser anulado. Use um tempo limite mesmo quando você também suporta o aborto.

JavaScript · retornos de chamada + aborto
// @connect api.example.com// @grant GM_xmlhttpRequest const request = GM_xmlhttpRequest({ url: 'https://api.example.com/slow-report', timeout: 15000, onload(response) { console.log('Loaded:', response.status); }, onerror(error) { console.error('Request failed:', error); }, ontimeout() { console.warn('Request timed out'); }, onabort() { console.log('Request aborted'); }}); // Cancel only if your script no longer needs the result.// request.abort();

Forma moderna: GM.xmlHttpRequest(...) and GM.xmlhttpRequest(...) mapear para o mesmo recurso de solicitação.

Recursos

Agrupar texto reutilizável, CSS ou outros ativos

Declarar um ativo com @resourcee leia-o pelo nome. GM_getResourceText returns decoded text. GM_getResourceURL returns a data URL that preserves the response MIME type.

JavaScript · @recurso
// ==UserScript==// @resource helperCss https://example.com/assets/helper.css// @grant GM_getResourceText// @grant GM_getResourceURL// ==/UserScript== const css = await GM_getResourceText('helperCss');console.log(css); const dataUrl = await GM_getResourceURL('helperCss');console.log(dataUrl);

Se o nome do recurso não existir, API retornará undefined. Mantenha os nomes dos recursos curtos e descritivos.

Ajudantes do navegador

Guias, notificações e área de transferência

GM_openInTab(url, options)

Abra um URL em uma guia Social Browser. Usar active: false quando a nova guia deve abrir sem tirar o foco.

JavaScript · abrir uma guia de plano de fundo
// @grant GM_openInTab GM_openInTab('https://example.com/report', { active: false});

Estado do script por guia: GM_getTab, GM_saveTab, GM_getTabs

Esses APIs armazenam pequenos estados User Script associados às guias. Eles são úteis quando um script precisa lembrar qual etapa ou visualização pertence a uma guia específica sem misturá-la com preferências globais de script.

JavaScript · lembre-se do estado desta guia
// @grant GM_getTab// @grant GM_saveTab// @grant GM_getTabs const tabState = await GM_getTab();await GM_saveTab({ ...tabState, lastPanel: 'orders'}); const allScriptTabs = await GM_getTabs();console.log(allScriptTabs);

GM_notification

Mostrar uma notificação do navegador sobre algo que o usuário realmente deveria notar. Evite spam de notificação para atividades rotineiras de script.

JavaScript · notificação
// @grant GM_notification await GM_notification({ title: 'Report ready', text: 'The page data is ready to review.'});

GM_setClipboard(data, type)

Copie o texto (ou HTML quando solicitado) para a área de transferência. Use-o após uma ação clara do usuário, quando possível, para que o usuário entenda por que sua área de transferência foi alterada.

JavaScript · copiar um valor de página
// @grant GM_setClipboard const orderId = document.querySelector('.order-id')?.textContent?.trim();if (orderId) { GM_setClipboard(orderId, 'text');}

Menus e downloads

Adicione ações deliberadas do usuário

GM_registerMenuCommand / GM_unregisterMenuCommand

Registre um comando no menu User Script. Este é um bom padrão para ações que devem acontecer somente quando o usuário as solicitar explicitamente.

JavaScript · comando de menu
// @grant GM_registerMenuCommand// @grant GM_unregisterMenuCommand const commandId = GM_registerMenuCommand( 'Highlight overdue rows', () => { document.querySelectorAll('.row.overdue').forEach((row) => { row.style.fontWeight = '700'; }); }); // Remove the menu item later if the script no longer needs it.// GM_unregisterMenuCommand(commandId);

GM_download

Inicie um download por meio de Social Browser. Dê ao arquivo um nome claro e use-o somente quando o download fizer parte do propósito visível do script.

JavaScript · baixar um arquivo
// @grant GM_download await GM_download({ url: 'https://example.com/reports/today.csv', name: 'today-report.csv'});

Avançado

unsafeWindow: ponte para páginas globais somente quando necessário

User Scripts de concessão explícita normalmente é executado em um mundo isolado. unsafeWindow é uma ponte opcional para globais no mundo PRINCIPAL da página. Use-o somente quando o site expõe uma variável ou função de página que o acesso comum por script isolado não consegue alcançar.

Use de forma restrita: as páginas globais pertencem ao site e podem ser alteradas sem aviso prévio. Prefira DOM APIs normais quando eles resolverem o problema.
JavaScript · leia uma página global
// @grant unsafeWindow const appVersion = unsafeWindow.appConfig?.version;if (appVersion) { console.log('Page app version:', appVersion);}

Regra do mundo de execução

MetadadosComportamento em Social Browser
@grant noneFunciona no mundo MAIN do quadro alvo exato sem injeção de capacidade GM.
Um ou mais explícitos @grantsÉ executado em um mundo User Script isolado determinístico; apenas os recursos solicitados são interligados.
No @grant metadadosO modo de compatibilidade legado do mundo MAIN é mantido para scripts Social Browser existentes.

Exemplo completo

Um pequeno script que combina armazenamento, estilos, comandos de menu e área de transferência

Este exemplo permanece intencionalmente pequeno. Ele lembra se o realce está habilitado, adiciona uma regra de estilo, permite ao usuário alterná-lo no menu User Script e copia um valor de página visível somente quando solicitado.

JavaScript · completar User Script
// ==UserScript==// @name Helpful order-page tools// @namespace https://example.com/my-scripts// @version 1.0.0// @match https://example.com/orders/*// @grant GM_getValue// @grant GM_setValue// @grant GM_addStyle// @grant GM_registerMenuCommand// @grant GM_setClipboard// ==/UserScript== (() => { 'use strict';  GM_addStyle(` .sb-order-highlight { outline: 2px solid currentColor; font-weight: 700; } `);  const applyHighlight = () => { const enabled = GM_getValue('highlightEnabled', true); document.querySelectorAll('.order-total').forEach((element) => { element.classList.toggle('sb-order-highlight', enabled); }); };  GM_registerMenuCommand('Toggle order highlighting', () => { const current = GM_getValue('highlightEnabled', true); GM_setValue('highlightEnabled', !current); applyHighlight(); });  GM_registerMenuCommand('Copy current order ID', () => { const orderId = document.querySelector('.order-id')?.textContent?.trim(); if (orderId) { GM_setClipboard(orderId, 'text'); } });  applyHighlight();})();

Nota de compatibilidade

O que este guia trata como contrato GM suportado

Este guia se concentra nos recursos que fazem parte do atual explícito do Social Browser @grant bridge: armazenamento, ouvintes de mudança de valor, estilos/elementos, solicitações privilegiadas, recursos, guias, notificações, área de transferência, downloads, comandos de menu, GM_info and unsafeWindow.

Alguns nomes herdados/internos podem existir para compatibilidade com versões anteriores, mas eles não são intencionalmente apresentados aqui como APIs públicos recomendados até que façam parte do contrato de capacidade explícito. Isso mantém os novos scripts no caminho estável, em vez de ensinar detalhes de implementação acidentais.

Abra a referência rápida User ScriptsAbra quando necessário

Recursos de script em Social Browser

CapabilityObjetivo
Nome/títuloIdentifique o roteiro claramente.
Permitido URLsEscolha onde ele pode ser executado.
URLs excluídoBloqueie a execução de páginas específicas.
JavaScriptAdicione lógica e comportamento de página.
CSSAlterar a aparência da página.
HTMLAdicione pequenos elementos de interface de página.
Visibilidade do menuControle se ela aparece como uma ação de script acionada pelo usuário.
Escopo de janela/quadroEscolha qual contexto do documento recebe o script.
Execução automáticaExecute nas páginas correspondentes automaticamente.
Execução do estágio de pré-carregamentoComece mais cedo quando o script exigir.
Importar do arquivo / URLTraga scripts existentes para o gerenciador.
Metadados User Script comunsUse convenções de metadados familiares quando houver suporte.

Glossário

User Script
JavaScript, opcionalmente com CSS/HTML, que é executado em páginas selecionadas do navegador.
Regra de correspondência
Uma regra que limita quais URLs recebem o script.
DOM
A representação do objeto do navegador da página que JavaScript pode ler e alterar.
Evento
Um sinal de página, como um clique ou alteração de entrada.
Quadro
Um documento incorporado em outra página.
Pré-carregar
Um estágio de execução anterior usado quando o tempo normal da página é tarde demais para uma necessidade específica.
Perfil
Um ambiente Social Browser persistente e isolado com seu próprio estado de navegador.

Lista de verificação para iniciantes

  • Posso explicar o que é User Script.
  • Criei e desativei um script de teste.
  • Posso limitar um script ao URLs correto.
  • Posso encontrar e alterar um elemento simples da página.
  • Eu sei quando CSS é suficiente.
  • Reviso o código importado antes de ativá-lo.
  • Posso usar o console para depurar um script.

Lista de verificação avançada

  • Eu mantenho as regras de jogo restritas.
  • Entendo páginas dinâmicas e observadores limitados.
  • Eu trato o armazenamento e o acesso à rede intencionalmente.
  • Eu escolho o escopo e o tempo do quadro por um motivo.
  • Eu testo scripts no contexto Profile pretendido.
  • Eu sei quando Automation Studio é uma ferramenta melhor.
Abra perguntas comuns sobre User ScriptAbra quando necessário
Preciso ser um desenvolvedor JavaScript?

Não. Pequenos scripts úteis geralmente precisam apenas de seleção básica de DOM, eventos e condições simples. Saiba mais sobre JavaScript quando um caso de uso real exigir.

Um User Script pode incluir CSS e HTML?

Sim. O sistema User Script de Social Browser pode incluir JavaScript e, dependendo do script, personalizações CSS e HTML.

Posso importar User Scripts existente?

Os scripts podem ser criados manualmente ou importados de um arquivo ou diretamente do URL, e convenções comuns de instalação/metadados do User Script são suportadas quando aplicável. Revise o código importado antes de ativá-lo.

User Scripts é igual a Automation Studio?

Não. User Scripts são melhores para códigos que convivem com páginas correspondentes. Automation Studio foi projetado para fluxos de trabalho ordenados, direcionamento de Profile, política de execução, agendamento, verificação e recuperação. Eles podem se complementar.

Os scripts podem ser executados em Profiles diferentes?

User Scripts opera em contextos de páginas do navegador. Teste e gerencie-os no Social Browser Profile pretendido porque os perfis podem ter diferentes sessões, conteúdo e estado do navegador.

Qual é a maneira mais segura de instalar um script da internet?

Conheça a fonte, leia os metadados, inspecione o código, verifique o escopo do URL e o comportamento da rede/armazenamento e, em seguida, teste em um Profile controlado antes do uso importante.

Pronto para testar?

Torne uma página melhor com um pequeno script.

Baixe Social Browser, crie um teste Profile, adicione um pequeno User Script e mantenha-o simples o suficiente para que você possa explicar cada linha.