Estrutura

Rich Snippets no WordPress – como usar Schema microdata

Google+ Pinterest LinkedIn Tumblr
Anúncios Google

Os sistemas de busca Bing, Google e Yahoo! uniram-se anos atrás em busca de um meio integrado de estruturar conteúdo indexado. Usando HTML5 e tags especiais, o “miolo” dos sites seria melhor entendido pelos robots de busca, e as empresas poderiam receber dados mais claros e exibir resultados mais precisos. Desse esforço surgiu o Schema.org, com uma coleção de itens e propriedades para rotular o conteúdo dos sites com os meta dados, ou microdata.

Funciona mais ou menos assim: você tem uma página com o perfil de um usuário, incluindo nome, endereço, avatar, telefone, etc. Para a ferramenta de busca, que só “varre” a internet em busca de dados, tudo não passa de conjuntos de letras e números, não tem significado real; você buscar por “joão da silva” ou “asdfjals poaksklt”, tecnicamente dava no mesmo.

Mas se usar marcação de microdata “name“, os buscadores “sabem” que aquele conteúdo se refere a um nome; o valor de “telephone” se refere a um telefone, e assim por diante. Programados para lidar com as marcações do Schema, os buscadores entendem onde na página estão os dados relevantes, e que podemos estar procurando.

Alguns temas e plugins de WordPress já fazem o trabalho de inserir metadados em certos campos, mas há sites e blogs grandes completamente pelados dessa estrutura. Ter ou não ter as marcações não interfere diretamente em posicionamento, segundo o próprio Google, pelo menos por enquanto, mas usá-los pode ser um diferencial, garantindo visitas a mais.

Acha bobagem? Quer uma prova? Qual desses resultados de busca por uma receita é mais interessante, tem mais detalhes e mereceria um clique?

richsnippets de receitas

Os dois primeiros, que só tem uma descrição, ou o terceiro, com foto, avaliações, tempo de preparo e valor calórico?

Tais dados estruturados são exibidos por quê? Por causa dos Rich Snippets. Vamos ver como gerar a estrutura dos Rich Snippets no WordPress.

Que isso, é de comer?

Os snippets do Google são informações adicionais que aparecem junto ao link quando fazemos uma busca. Você já viu, o mundo já viu. Ele dá uma prévia do que o link contém, ajudando a saber se é aquilo mesmo que quermos. Usam a marcação do Schema e outros como RDFa e microformatos, mas não serão abordados aqui por serem mais complicados; além disso, Schema é a opção “oficial” para o Google. Sites e blogs que usam os microdados, quando têm relevância, aparecem com esses eles no resultado. Alguns exemplos:

Rich Snippets em reviews:

richsnippets avaliação

Rich Snippets em receitas:

richsnippets receitas

Rich Snippets em aplicativos:

richsnippets aplicativo

Rich Snippets em música:

richsnippets música

Rich Snippet básico (links internos):

richsnippets google

Rich Snippets do Google são gerados a partir de microdata, aplicáveis em vários tipos de conteúdo; o Schema tem opções para organizar dados de pessoas, organizações, reviews, produtos, ofertas, softwares, livros, lojas, eventos e mais um monte de formatos. Esses dados serão relacionados ao conteúdo que estiver “envolvido”, por exemplo numa div.

Assim, se tivermos uma div “Person” (Pessoa), um metadado “name” dentro da div fará referência ao nome de uma pessoa. Outra informação “name” fora da div “Person” mas dentro da div “Product“, estará relacionada ao nome do produto, etc.

Parece complicado lendo, então vejamos um modelo básico. Digamos que você tem um blog sobre cinema, e uma página fala sobre o filme “Tubarão”.

Teríamos um trecho assim:

<div>
    <h1>Tubarão</h1>
    <span>Diretor: Steven Spielberg (nascido em 18/12/1946)</span>
    <span>Ano: 1975</span>
    <span>Gênero: suspense</span>
    <a href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

Ótimo, uma pessoa lê e reconhece na hora: é uma ficha sobre o filme Tubarão. Mas para os buscadores é o mesmo que “blabla blabla“. O sistema indexa, mas não rotula aquilo como nada específico. Pessoas procurando por “pessoa chamada blablabla”, “rua chamada blablabla” ou “produto chamado blablabla”, podem ver o mesmo resultado.

Vamos usar a “língua” entendida pelos buscadores, ou melhor, arrumar um “tradutor” — os microdados do Schema — para dizer que isso tudo são dados sobre um filme.

Pra começar, dando um significado ao bloco todo, usamos o elemento “itemscope” na div principal. O itemscope “diz” que ali há elementos sobre alguma coisa (um item). Fica assim:

<div itemscope>
 <h1>Tubarão</h1>
 <span>Diretor: Steven Spielberg (nascido em 18/12/1946)</span>
 <span>Ano: 1975</span>
 <span>Gênero: suspense</span>
 <a href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

Ok, o buscador agora vai entender que a div guarda informações sobre um item, você disse para ele “Ei Google, Bing e outros, aqui nessa div temos um item, vejam!“. Mas eles olharam e não entenderam nada, ficaram tentando saber que item é esse. Para que saibam de qual item se trata, precisamos especificar o tipo de item.

Pra isso, o atributo “itemtype” (tipo de item), com um valor. Estamos falando de um filme, então, procurando lá no Schema, descobrimos que existe um itemtype “Movie”, perfeito.

Para usar, é só indicar a URL do tipo de item, assim:

<div itemscope itemtype="http://schema.org/Movie">
    <h1>Tubarão</h1>
    <span>Diretor: Steven Spielberg (nascido em 18/12/1946)</span>
    <span>Ano: 1975</span>
    <span>Gênero: suspense</span>
    <a href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

Agora nosso bloco já diz ao buscador: “Ei, aqui na div tenho informações (itemscope) sobre um filme (itemtype)”E o buscador responde: “Ok, eu vi. Mas qual filme? Não vejo o nome!

Não demos qualquer pista, o “Tubarão” ali é o mesmo que “blablabla” ainda. Para identificar as propriedades de um item, existem as itemprop.

Lendo a página do itemtype Movie, vemos uma propriedade “name“, que é comum a todos os tipos de “coisas” (itemtype Thing), incluindo filmes:

Propriedades do itemtype Movie

Segundo a descrição, a propriedade name é “o nome de um item”, e deve ser preenchida (Expected Type) por texto. Exatamente o que precisamos para dizer ao buscador qual o nome do nosso item filme.

Então, damos ao nome do filme uma propriedade (itemprop) que o identifique como um nome:

<div itemscope itemtype="http://schema.org/Movie">
    <h1 itemprop="name">Tubarão</h1>
    <span>Diretor: Steven Spielberg (nascido em 18/12/1946)</span>
    <span>Ano: 1975</span>
    <span>Gênero: suspense</span>
    <a href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

O h1 ganhou a propriedade “name“; dissemos agora ao buscador que o conteúdo desse cabeçalho é um nome. Logo, com o resto da marcação, temos a div falando de um item, o item é um filme, cujo nome é “Tubarão”.

Simples, não? É só envolver o conteúdo com um elemento e dar-lhe a itemprop necessária.

Mais propriedades vindas do itemtype Movie: diretor (director), gênero (genre), trailer e data de copyright (copyrightYear). Nota: para datas completas, leia as notas no final. Não adianta só passar a data, tem que ter o formato certo.

<div itemscope itemtype="http://schema.org/Movie">
    <h1 itemprop="name">Tubarão</h1>
    <span>Diretor: <span itemprop="director">Steven Spielberg</span> (nascido em 18/12/1946)</span>
    <span>Ano: <span itemprop="copyrightYear">1975</span></span>
    <span>Gênero: <span itemprop="genre">suspense</span></span>
    <a itemprop="trailer" href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

Note que um span é usado para envolver só o conteúdo da propriedade. Assim, em itemprop=”director”, não envolvemos tudo, incluindo o rótulo “Diretor:”, mas fazemos outro span pegando só o nome do diretor. Ou seja:

Errado:

<span itemprop="director">Diretor: Steven Spielberg</span>

O buscador perguntaria: “Hein, o nome do direto é “Diretor: Steven Spielberg”?”

Certo:

<span>Diretor: <span itemprop="director">Steven Spielberg</span></span>

O buscador diria: “Ah, o nome do direto é “Steven Spielberg”!“.

As ferramentas de busca agora tem mais dados: nome do filme, ano do copyright, URL do trailer, gênero, etc.

Mas tem um detalhe: diretor Steven Spielberg. Mas o buscador é burrinho e pensaria “que significa isso, Steven Spielberg?). Temos que dizer a ele que Steven Spielberg é uma pessoa.

Item dentro de item

Vai acontecer de um item estar dentro de outro. Por exemplo, dissemos ao buscador que o diretor do filme é “Steven Spielberg” (ou melhor, o conteúdo do campo director é Steven Spielberg), mas ele não associa essas palavras a nada, é só um conjunto de letras. Steven Spielberg, para o sistema, pode ser qualquer coisa: uma pessoa, uma banda, o nome de um prédio, um animal, etc. Como dizer que aquilo é o nome de uma pessoa?

Usando outro itemtype, o Person. É só envolver as informações do mesmo jeito que fez antes. Os dados referente à pessoa serão colocadas num elemento Person:

<div itemscope itemtype="http://schema.org/Movie">
    <h1 itemprop="name">Tubarão</h1>
    <div itemprop="director" itemscope itemtype="http://schema.org/Person">
        <span>Diretor: <span itemprop="name">Steven Spielberg</span> (nascido em 18/12/1946)</span>
    </div>
    <span>Ano: <span itemprop="copyrightYear">1975</span></span>
    <span>Gênero: <span itemprop="genre">suspense</span></span>
    <a itemprop="trailer" href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

Agora ficou melhor. A div tem a propriedade director, propriedade do item-div principal, “Movie“, referindo-se ao item filme. Ao mesmo tempo, tem uma informação falando de outro item (o itemscope avisa isso): uma pessoa (o itemtype).

Para entender a estrutura mais visualmente, temos algo como:

MOVIE >
          name = Tubarão
          director > PERSON >
                    name = Steven Spielberg
          copyrightYear = 1975
          genre = suspense
          trailer = url

Mas como temos a data de nascimento do diretor, por que não dizer ao buscador também isso? Use o propriedade birthDate, de Person.

<div itemscope itemtype="http://schema.org/Movie">
    <h1 itemprop="name">Tubarão</h1>
    <div itemprop="director" itemscope itemtype="http://schema.org/Person">
    <span>Diretor: <span itemprop="name">Steven Spielberg</span> (nascido em <span itemprop="birthDate">18/12/1946</span>)</span>
   </div>
    <span>Ano: <span itemprop="copyrightYear">1975</span></span>
    <span>Gênero: <span itemprop="genre">suspense</span></span>
    <a itemprop="trailer" href="../filme-tubarao-trailer.html">Trailer de Tubarão</a>
</div>

Agora você diz ao navegador que a data de nascimento da pessoa é “18/12/1946”. Naquela indentação acrescentamos um dado:

MOVIE >
          name = Tubarão
          director > PERSON >
                    name = Steven Spielberg
                    birthDate = 18/12/1946
          copyrightYear = 1975
          genre = suspense
          trailer = url

Podemos continuar, se existirem mais dados e marcação disponível. Por exemplo, para indicar o sexo do diretor, use a itemprop gender (ou seja, itemprop=gender); para cada membro do elenco do filme, itemprop=actor (lembre-se de usar Person para dizer o nome dos atores e atrizes), e assim por diante, é só manter cada dado dentro de sua estrutura-pai.

Veja todas as propriedades de Movies aqui, e propriedades de Person aqui.

Rich Snippets no WordPress

Se estudar um pouco as propriedades e itens no Schema.org, verá que podem ser empregados em blogs de reviews, culinária, cinema, música e tantos outros temas. É complicado usar direto dentro dos posts, pelo editor, então uma boa é recorrer aos campos personalizados, carregando dados dentro do código do tema, em widgets, caixas de autor, etc.

Tem que conhecer um pouco (ou bastante, de preferência) de PHP. Não vou entrar em detalhes agora sobre uso de campos personalizados, mas mostrar um uso básico. Se quiser mais, você acha tudo sobre eles no Codex do WordPress.

Digamos que tenho um blog com reviews de filmes. Bastariam alguns campos personalizados para os dados do filme (nome, gênero, etc) e um para a avaliação, uma nota de 1  a 10.

exemplos de custom fields

Note que esse é o modo mais direto e simples de criar campos personalizados, você pode usar plugin, funções, etc. O importante é ter campos para salvar dados no artigo.

Então, com o post de review já salvo com os campos personalizados preenchidos, carrego os dados deles dentro do meu post com uma função — usei a get_post_meta na estrutura do tema (no TwentyThirteen, foi colocado no content.php, logo após abrir a div “entry-content”). Assim:

<?php
 global $wp_query;
 $postid = $wp_query->post->ID;
 echo '<div><ul>
 <li>Filme: '. get_post_meta($postid, 'Filme', true) .'</li>
 <li>Ano: '. get_post_meta($postid, 'Ano', true) .'</li>
 <li>Gênero: '. get_post_meta($postid, 'Gênero', true) .'</li>
 <li>Diretor: '. get_post_meta($postid, 'Diretor', true) .'</li>
 <li>Nascimento: '. get_post_meta($postid, 'Diretor_nascimento', true) .'</li>
 <li><a href="'. get_post_meta($postid, 'URL_trailer', true) .'">Trailer</a></li>
 <li>Nota: '. get_post_meta($postid, 'Nota', true) .'</li>
 </ul></div>';
 wp_reset_query();
 ?>

…pra obter dentro do post uma lista com dados sobre o filme, desse jeito:

modelo de dados dos custom fields

Agora é só colocar as propriedades como visto antes, estruturando.

<?php
 global $wp_query;
 $postid = $wp_query->post->ID;
 echo '<div itemscope itemtype="http://schema.org/Movie"><ul>
 <li>Filme: <span itemprop="name">'. get_post_meta($postid, 'Filme', true) .'</span></li>
 <li>Ano: <span itemprop="copyrightYear">'. get_post_meta($postid, 'Ano', true) .'</span></li>
 <li>Gênero: <span itemprop="genre">'. get_post_meta($postid, 'Gênero', true) .'</span></li>
 <div itemprop="director" itemscope itemtype="http://schema.org/Person">
 <li>Diretor: <span itemprop="name">'. get_post_meta($postid, 'Diretor', true) .'</span></li>
 </div>
 <li>Nascimento: <span itemprop="birthDate">'. get_post_meta($postid, 'Diretor_nascimento', true) .'</span></li>
 <li><a itemprop="trailer" href="'. get_post_meta($postid, 'URL_trailer', true) .'">Trailer</a></li>
 <li>Nota: '. get_post_meta($postid, 'Nota', true).'</li>
 </ul></div>';
 wp_reset_query();
?>

Usei uma div no meio da lista para o itemtype Person (se houver problema com isso devido a estilos, use um span). Quase todas as informações já estão compatíveis com o Schema para os serviços de busca — faltou ali a nota, veja que ela não tem nenhuma itemprop. Vamos resolver.

Reviews

Para exibir a nota do filme no resultado de busca, com estrelas, como nos modelos do começo, usaremos o itemtype “Review”. É só completar o snippet anterior: criamos um campo com itemscope para declarar que o trecho é sobre um item, e itemtype Review. Essa mesma div usa a propriedade review, pois é um review do item-pai Movie.

Então, colocamos a propriedade “reviewRating” num span envolvendo o valor da nota:

<?php
 global $wp_query;
 $postid = $wp_query->post->ID;
 echo '<div itemscope itemtype="http://schema.org/Movie"><ul>
 <li>Filme: <span itemprop="name">'. get_post_meta($postid, 'Filme', true) .'</span></li>
 <li>Ano: <span itemprop="copyrightYear">'. get_post_meta($postid, 'Ano', true) .'</span></li>
 <li>Gênero: <span itemprop="genre">'. get_post_meta($postid, 'Gênero', true) .'</span></li>
 <div itemprop="director" itemscope itemtype="http://schema.org/Person">
 <li>Diretor: <span itemprop="name">'. get_post_meta($postid, 'Diretor', true).'</span></li>
 </div>
 <li>Nascimento: <span itemprop="birthDate">'. get_post_meta($postid, 'Diretor_nascimento', true) .'</span></li>
 <li><a itemprop="trailer" href="'. get_post_meta($postid, 'URL_trailer', true) .'">Trailer</a></li>
 <div itemprop="review" itemscope itemtype="http://schema.org/Review">
  <li>Nota: <span itemprop="reviewRating">'. get_post_meta($postid, 'Nota', true) .'</span></li>
 </div>
 </ul></div>';
 wp_reset_query();
?>

Mas não é o bastante, pois o schema para reviews precisa saber quais as notas mínima e máxima possíveis para assim gerar o snippet com as estrelas. Isso é fácil: vamos inserir duas meta tags, que não são visíveis na página, mas sim para o buscador.

<?php
 global $wp_query;
 $postid = $wp_query->post->ID;
 echo '<div itemscope itemtype="http://schema.org/Movie"><ul>
 <li>Filme: <span itemprop="name">'. get_post_meta($postid, 'Filme', true) .'</span></li>
 <li>Ano: <span itemprop="copyrightYear">'. get_post_meta($postid, 'Ano', true) .'</span></li>
 <li>Gênero: <span itemprop="genre">'. get_post_meta($postid, 'Gênero', true) .'</span></li>
 <div itemprop="director" itemscope itemtype="http://schema.org/Person">
 <li>Diretor: <span itemprop="name">'. get_post_meta($postid, 'Diretor', true) .'</span></li>
 </div>
 <li>Nascimento: <span itemprop="birthDate">'. get_post_meta($postid, 'Diretor_nascimento', true) .'</span></li>
 <li><a itemprop="trailer" href="'. get_post_meta($postid, 'URL_trailer', true).'">Trailer</a></li>
 <div itemprop="review" itemscope itemtype="http://schema.org/Review">
 <meta itemprop="worstRating" content="1" />
 <meta itemprop="bestRating" content="10" />
 <li>Nota: <span itemprop="reviewRating">'. get_post_meta($postid, 'Nota', true) .'</span></li>
 </div>
 </ul></div>';
 wp_reset_query();
?>

A primeira meta tag com itempropworstRating” (pior cotação) leva o pior valor possível de nota. Se seus reviews permitem nota zero, coloque 0. A outra, “bestRating“, é a melhor nota possível.

Agora falta dizer ao buscador quem é o autor da resenha. Vamos de novo usar o item Person, com o nome do autor do artigo. O WordPress tem funções pra pegar o nome do autor, então vamos usá-las. Você pode pegar esse nome de onde achar melhor – se o blog tem aquela caixa de autor do post, pode ser de lá, mas ela também precisa estar dentro da div Review.

Se não estiver ou você não usa caixa de autor, vamos com meta tags escondidas de novo:

<?php
 global $wp_query;
 $postid = $wp_query->post->ID;
 echo '<div itemscope itemtype="http://schema.org/Movie"><ul>
 <li>Filme: <span itemprop="name">'. get_post_meta($postid, 'Filme', true) .'</span></li>
 <li>Ano: <span itemprop="copyrightYear">'. get_post_meta($postid, 'Ano', true) .'</span></li>
 <li>Gênero: <span itemprop="genre">'. get_post_meta($postid, 'Gênero', true) .'</span></li>
 <div itemprop="director" itemscope itemtype="http://schema.org/Person">
 <li>Diretor: <span itemprop="name">'. get_post_meta($postid, 'Diretor', true) .'</span></li>
 </div>
 <li>Nascimento: <span itemprop="birthDate">'. get_post_meta($postid, 'Diretor_nascimento', true) .'</span></li>
 <li><a itemprop="trailer" href="'. get_post_meta($postid, 'URL_trailer', true) .'">Trailer</a></li>
 <div itemprop="review" itemscope itemtype="http://schema.org/Review">
 <meta itemprop="worstRating" content="1" />
 <meta itemprop="bestRating" content="10" />
 <div itemprop="author" itemscope itemtype="http://schema.org/Person" />
 <meta itemprop="name" content="'. get_the_author() .'" />
 </div>
 <li>Nota: <span itemprop="reviewRating">'. get_post_meta($postid, 'Nota', true) .'</span></li>
 </div>
 </ul></div>';
 wp_reset_query();
 ?>

Ou seja, uma div com itemscope indicando que ali fala-se de um item, do tipo (itemtype) Person. O itempropauthor” diz que o item/pessoa é autora do elemento-pai, a div Review (pois está dentro dela). E para dizer o nome da pessoa, a função “get_the_author” do WordPress.

E só. Com a página online e tudo funcionando, teste com a ferramenta de teste de dados estruturados do Google. Deverá ser algo parecido com isso (foi feito no Photoshop, mas tem que ser igual ou muito parecido):

fake richsnippet filme

Se quiser ir além, sugiro que dê uma olhada na página de introdução ao Schema e nas dicas do Google sobre dados estruturados, deve ajudar.

Notas finais

– Microdata (caso do Schema) só funciona com HTML5 e XHTML5. Logo, se sua página tem que estar em outra estrutura, será preciso usar microformatos ou RDFa. Mas não se preocupe, pode usar tranquilo com o WordPress.

– Atenção ao criar campos personalizados e usar o método mostrado para chamar os valores. Letras maiúsculas e acentuação também diferenciam nomes, então um campo “Gênero”, se chamado como “genero” ou “gênero”, não vai funcionar.

– A ferramenta de visualização só funciona para sites online, nem adianta testar sites em localhost. É meio óbvio, mas vai que alguém esquece e fica me xingando depois.

– O Bing tem sua página para validação de marcação que exibe a estrutura em árvore, mais ou menos como fiz nesse post lá em cima, mas não mostra preview do richsnippet. Se quiser, teste a ferramenta aqui (login exigido na sua conta do Hotmail).

– O tipo de review do exemplo é para autores simples, ou seja, uma pessoa ou organização dando a nota. Para reviews agregados, aqueles de estrelas em que muitas pessoas avaliam, há outro item, o AggregateRating, e outra propriedade, a “aggregateRating”. A estrutura é:

<div itemprop="aggregateRating" itemscope itemtype="http://schema.org/AggregateRating">
 <span itemprop="ratingValue">4</span> estrelas -
 <span itemprop="reviewCount">3077</span> reviews
</div>

A propriedade “ratingValue” é igual antes, indica a nota dada (em reviews agregados de plugins de estrela, por exemplo, o valor é calculado por alguma função em PHP). Já o “reviewCount” é a contagem total de avaliações. Não é preciso o valor máximo e mínimo (best e worstRating) como nos reviews únicos.

– Datas e horários não devem ser indicados para os snippets do mesmo jeito que exibidos para os leitores, o buscador “não fala nossa língua”. Por exemplo, “04/01/07” pode ser 04 de janeiro de 2007, ou 01 de abril de 2007, ou 07 de janeiro de 2004. É um caos. Por isso foi padronizado o uso de datas no formato ISO 8601.

Mas como resolver isso se o leitor não vai entender bulhufas da data em ISO? Usar meta tags de novo, e convertendo a data em PHP (ou já pegando no formato certo, quando possível). Eu faço assim para pegar a data da publicação do post, por exemplo:

<meta itemprop="datePublished" content="<?php echo the_time('Y-m-d'. T .'H:i:s' .Z); ?>" />

Isso vai dar ao buscador a data de 04/01/2007 assim: 2007-01-04T22:12:17+00:00 – considerando que sua data também tenha a hora. Para anos simples, use só o número, tipo “2007”, enquanto para apenas dia, mês e ano, use:

<meta itemprop="datePublished" content="<?php echo the_date('Y-m-d'); ?>" />

– Se seu blog é pequeno e ainda considerado irrelevante ou pouco relevante pelo Google, você pode fazer a estruturação mais fantástica do universo: não vai aparecer nada de excepcional nos Rich Snippets; no máximo, na ferramenta de testes. Nesse caso, trabalhe mais no seu blog para tornar seu conteúdo melhor e mais relevante. A detecção é automática.

 

Qualquer dúvida ou sugestão, comente.

Fundador do Tutoriart em 2010, é ex-instrutor de Photoshop, design web e gráfico. Em quase uma década de redação online, tem cerca de 1500 artigos publicados. Gerencia também o Memória BIT.

5 Comments

  1. Olá, bom dia!
    Gostei muito do post. Mas ainda tenho uma dúvida… Tenho 2 páginas no wordpress e queria acrescentar o schema, mas quando faço isso através de um plugin “Schema Creator by Raven”, desconfigura a minha página… no meu search console aparece o erro “person” no “schema.org”… no plugin tem a parte para acrescentar o “person”, mas não sei em que parte do código colocar isso… qual a estrutura HTML para que não desconfigure a minha página… tens como me ajudar? 🙂

  2. Olá boa tarde

    Tenho uma dúvida, onde eu coloco o código dentro do wordpress sem ter que usar plugin?

    Muito bom seu artigo, parabéns.

  3. Claudio Myst Reply

    Pelo amor de Deus, que post é esse cara!!!
    Fantástico, várias explicações muito bem colocadas e explicadas de uma forma clara e descontraída. Perfeito mesmo.

    Se achou que este post não rendeu muita coisa pela falta de comentários, saiba que pelo menos ganhou um leitor, pois agora serei obrigado a ler todos os seus post.

Write A Comment

Pin