> [Site index](https://perfectvector.com/llms.txt) — available pages and descriptions. # Logos SVG no Satori: preserve a arte no cartão da marca > Incorpore um logo SVG em um cartão Satori com dimensões explícitas e dados independentes. Examine a arte aninhada e renderize um PNG separado para entrega. Source: https://perfectvector.com/pt-BR/blog/satori-svg-logo Language: pt-BR Author: Irene Kim Published: 2026-10-05T08:00:00+09:00 Updated: 2026-10-05T08:00:00+09:00 Para colocar um logotipo SVG em um cartão Satori, passe-o como origem de imagem, defina largura e altura da imagem e mantenha o SVG original junto do cartão gerado. No exemplo abaixo, um SVG base64 se torna uma imagem aninhada na saída do Satori. Não se torna uma nova coleção de caminhos editáveis do logo no cartão externo. O Satori cria SVG a partir de um conjunto limitado de HTML e CSS. Sua [orientação oficial sobre imagens](https://github.com/vercel/satori#images) recomenda dimensões explícitas e dados de imagem independentes quando um renderizador posterior produzirá PNG. Isso dá a este trabalho duas saídas separadas: um cartão SVG composto e uma cópia raster de entrega. ## Mantenha três arquivos com tarefas diferentes | Arquivo | O que contém | O que mudar nele | | -------------------- | ----------------------------------------------- | ------------------------------------------- | | SVG original do logo | Geometria e abertura do emblema | Forma, cor, limites da origem | | SVG do cartão Satori | Layout, letras e uma imagem incorporada do logo | Caixa da arte, posição e conteúdo do cartão | | PNG renderizado | Pixels do cartão entregue | Regere após mudanças na origem | Um `` SVG pode referenciar outro SVG, como explica a [referência de image da MDN](https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/image). Portanto, um elemento de imagem não significa automaticamente que a arte incorporada é raster. Examine seu tipo de dados e conteúdo decodificado antes de diagnosticar o cartão com a [lista mais ampla de imagens raster em SVG](https://perfectvector.com/pt-BR/blog/svg-contains-raster-image). **Guarde o original junto do cartão** ![Ilustração conceitual de um original losangular vazado e cópias colocadas em tamanhos diferentes em cartões simples de marca](https://perfectvector.com/blog/satori-svg-logo/master-and-card.webp) *Ilustração: mantenha a arte editável separada da composição do cartão. A inspeção de origem e saída abaixo vem de um exemplo Satori criado de forma independente, não deste diagrama gerado.* ## Um exemplo local completo Este exemplo usa a importação padrão de saída SVG do [Satori 0.35.0](https://github.com/vercel/satori/releases/tag/0.35.0) e resvg-js 2.6.2. Em uma pasta de trabalho vazia, instale os pacotes fixados: ```bash npm install --save-exact satori@0.35.0 @resvg/resvg-js@2.6.2 ``` Crie uma pasta `fonts` e baixe `Abel-Regular.ttf` e `OFL.txt` do [diretório Abel do Google Fonts](https://github.com/google/fonts/tree/main/ofl/abel). Abel usa a [SIL Open Font License 1.1](https://raw.githubusercontent.com/google/fonts/main/ofl/abel/OFL.txt); mantenha o aviso e a licença acompanhantes ao distribuir a fonte com este exemplo. Salve o conteúdo a seguir como `starter.mjs` e execute `node starter.mjs`. Ele fornece a fonte ao Satori, cria um losango vazado e faz dois cartões 600×320 com caixas de arte de 80×80 e 160×160. URLs de arquivo mantêm os caminhos da fonte e da saída relativos ao script. ```js import { readFile, writeFile } from 'node:fs/promises'; import satori from 'satori'; import { Resvg } from '@resvg/resvg-js'; const logo = ``; const src = `data:image/svg+xml;base64,${Buffer.from(logo).toString('base64')}`; const font = await readFile(new URL('./fonts/Abel-Regular.ttf', import.meta.url)); await writeFile(new URL('./logo-master.svg', import.meta.url), logo); for (const size of [80, 160]) { const svg = await satori({ type: 'div', props: { style: { display: 'flex', width: 600, height: 320, backgroundColor: '#f6f2e8', color: '#152e29', fontFamily: 'Abel' }, children: [ { type: 'img', props: { src, width: size, height: size, style: { position: 'absolute', left: 24, top: 64 } } }, { type: 'div', props: { style: { position: 'absolute', left: 220, top: 112, fontSize: 42 }, children: 'CEDAR FIELD' } }, { type: 'div', props: { style: { position: 'absolute', left: 220, top: 168, fontSize: 20 }, children: 'A study in simple shapes' } }, ], }, }, { width: 600, height: 320, fonts: [{ name: 'Abel', data: font, weight: 400, style: 'normal' }], }); const png = new Resvg(svg, { font: { loadSystemFonts: false } }).render().asPng(); await writeFile(new URL(`./card-${size}.svg`, import.meta.url), svg); await writeFile(new URL(`./card-${size}.png`, import.meta.url), png); } ``` `Buffer.from(logo).toString('base64')` codifica os bytes UTF-8 do SVG criado usando a [API de codificação Buffer do Node](https://nodejs.org/api/buffer.html#buffers-and-character-encodings). O prefixo `data:image/svg+xml;base64,` identifica o conteúdo. Ele muda a representação de transporte, não a geometria do logotipo. A chamada do Satori retorna o SVG do cartão. A linha seguinte passa esse SVG ao [renderizador PNG resvg-js separado](https://github.com/thx/resvg-js#basic-usage). O exemplo não tem URL de imagem remota; lê a fonte local antes de renderizar. Teste separadamente seu próprio comportamento de busca remota ou implantação. ## O que as duas chamadas reais produziram Executamos exatamente este exemplo com os pacotes fixados, examinamos os dois SVGs de saída e abrimos cada SVG e PNG em um navegador. Os quatro arquivos de cartão carregaram a 600×320. As letras ficaram na mesma posição enquanto a caixa do emblema dobrou de tamanho. Cada cartão continha um `` externo e dois elementos `` externos. Os dois caminhos representavam as letras; não eram os contornos externo e interno do losango. Decodificar os dados base64 da imagem recuperou os bytes exatos do SVG original: um caminho, zero elementos de imagem e a mesma definição de losango vazado. O cartão não tinha elementos `` ativos nesta execução. | Inspeção | Caixa da arte 80×80 | Caixa da arte 160×160 | | ---------------------------------------------- | ------------------- | ------------------------ | | Dimensões do cartão | 600×320 | 600×320 | | Posição da imagem externa | x24, y64 | x24, y64 | | SVG incorporado | Original 128×128 | Mesmos bytes do original | | Limites PNG da cor verde-petróleo sólida exata | 68×68 pixels | 138×138 pixels | | Pixel do cartão no centro da abertura | Creme, alfa 255 | Creme, alfa 255 | As linhas de limites de pintura contam pixels que correspondem exatamente à cor verde-petróleo sólida do emblema. Excluem bordas com antisserrilhamento. Não são as dimensões do retângulo da imagem: o losango original vai das coordenadas de origem 8 a 120, portanto sua extensão matemática seria escalada para 70 ou 140 unidades nessas caixas. Os limites medidos de cor sólida foram um pouco menores. O centro do emblema original era transparente, com alfa 0 quando renderizado sozinho. Em cada PNG final do cartão, a abertura mostrou o fundo creme opaco: RGBA 246,242,232,255. Uma abertura visível e um pixel transparente no cartão final são requisitos diferentes. Se precisa de fundo transparente na entrega, mude o fundo do cartão e examine o alfa resultante separadamente. São duas chamadas usando um emblema original em dois tamanhos. Não estabelecem que todo recurso SVG funciona, que trabalhos repetidos de imagens remotas estão resolvidos ou que todos os destinos renderizam o cartão de forma idêntica. ## Mude a caixa da arte sem perder a origem Para seu próprio logo, substitua a string `logo` por um SVG independente ou leia o arquivo original antes de codificá-lo. Confira primeiro `viewBox`, largura, altura e abertura. Espaço vazio extra nesses limites pode deixar o logo visível menor que a caixa atribuída no cartão. Defina as duas dimensões da imagem para corresponder à proporção pretendida. Nossa origem é quadrada, assim como as duas caixas; a imagem de saída usou `preserveAspectRatio="none"`, o que não causou mudança de proporção aqui. Este arquivo de teste não verifica um logo retangular forçado em um espaço quadrado. Mude uma variável de layout por vez e examine o SVG real e o PNG de entrega. Mantenha as letras fora do logo incorporado quando quiser mudá-las de forma independente. O texto do cartão deste exemplo vira caminhos no SVG entregue, mas as palavras continuam editáveis no script. Entrada de fonte, entrada de arte e saída composta têm tarefas diferentes; o [passo a passo de fontes no resvg](https://perfectvector.com/pt-BR/blog/resvg-svg-fonts) cobre um fluxo separado de renderização de texto SVG ativo. A [documentação de HTML e CSS do Satori](https://github.com/vercel/satori#html-elements) descreve o subconjunto suportado e seus limites. Uma captura no navegador da sua página existente não é uma promessa de que esse mecanismo de layout a reproduzirá exatamente. Comece com um cartão pequeno e a importação comum de `satori` e acrescente as propriedades de que seu design realmente precisa. ## Prepare um logo que começa em pixels Se seu único logotipo é PNG ou JPG e você precisa de contornos editáveis, [prepare um logo SVG com o PerfectVector](https://perfectvector.com/pt-BR/vectorize-logo), examine a silhueta e as aberturas internas e mantenha esse SVG limpo como original mestre. Depois incorpore-o ao cartão e verifique os dois tamanhos de arte e o PNG final. A vetorização prepara a arte; o Satori faz a composição do cartão. Um SVG limpo existente pode ir direto à etapa de incorporação. O [guia de vetorização](https://perfectvector.com/pt-BR/blog/what-is-image-vectorization) explica a distinção entre origem e saída. Mantenha o original, o script e as fontes de entrada depois de entregar o PNG. Se usar outra etapa de rasterização, verifique seu dimensionamento separadamente; o [exemplo SVG para PNG com Sharp](https://perfectvector.com/pt-BR/blog/sharp-svg-to-png) cobre as dimensões desse renderizador. ## Perguntas frequentes **Uma imagem SVG vira caminhos editáveis no cartão Satori?** Neste exemplo, o logo continua sendo uma imagem SVG aninhada. Sua origem original de um caminho é preservada nos dados da imagem; os caminhos externos do cartão são letras. Mantenha o original para editar a geometria. **Por que o logo visível é menor que sua largura e altura?** A caixa de imagem inclui os limites da origem. Nosso losango deixa margens dentro de uma origem 128×128, e limites de pixels de cor exata também excluem bordas com antisserrilhamento. Examine separadamente o espaço vazio da origem e a proporção atribuída. **O furo transparente do logo torna o cartão transparente?** O furo deixa o fundo do cartão aparecer. Nosso fundo creme é opaco, portanto o pixel PNG na abertura tem alfa 255. Teste um fundo transparente do cartão separadamente se sua entrega exigir isso. **O Satori retorna o PNG?** Este exemplo pede ao Satori uma string SVG e depois a renderiza em PNG com resvg-js. Mantenha essas etapas separadas para examinar layout e entrega raster independentemente. ## Fontes 1. [Documentação de imagens, layout e fontes do Satori](https://github.com/vercel/satori) — dimensões de imagem, entradas independentes, saída SVG padrão e escopo de HTML/CSS suportado. 2. [Lançamento Satori 0.35.0](https://github.com/vercel/satori/releases/tag/0.35.0) — versão fixada usada no exemplo original. 3. [Elemento image SVG](https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/image) — imagens SVG podem referenciar outros arquivos SVG. 4. [API de codificação Buffer do Node](https://nodejs.org/api/buffer.html#buffers-and-character-encodings) — operação de codificação base64 do exemplo. 5. [Uso do resvg-js](https://github.com/thx/resvg-js) — etapa separada de renderização de SVG para PNG. 6. [Licença da fonte Abel](https://raw.githubusercontent.com/google/fonts/main/ofl/abel/OFL.txt) — origem, aviso e licença de redistribuição da fonte. *** Para seu próprio logo PNG ou JPG, [prepare um original SVG com o PerfectVector](https://perfectvector.com/pt-BR/vectorize-logo) e examine seu contorno e aberturas internas. Mantenha o original e confira sua posição no cartão SVG e no PNG entregue nos tamanhos que pretende usar. ## Explore - [Read the HTML article](https://perfectvector.com/pt-BR/blog/satori-svg-logo) - [Ícones SVG no MapLibre: pixels e tamanho do símbolo](https://perfectvector.com/pt-BR/blog/maplibre-svg-symbol-image.md) - [Imagens SVG no p5.js: carregue, escale e guarde a origem](https://perfectvector.com/pt-BR/blog/p5js-svg-artwork.md) - [Product facts](https://perfectvector.com/product-facts.md) - [FAQ](https://perfectvector.com/faq.md) - [Pricing and credits](https://perfectvector.com/pricing.md)