Website profiles · Technology insights · Alternatives

colors.eva.design

Generate color pallets using deep learning powered algorithm

No paid content found
Visit website
Profile views 17 Outbound visits 5 Normal
Eva Design System: Deep learning color generator Full homepage screenshot

At a glance

Category
Design & Creativity
Language
English
Paid-content signal
No paid content foundObserved
Registered
2019
Hosting
CloudflareInferred
HTTPS certificate trusted
PassedObserved
Last updated

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is Eva Design System: Deep learning color generator?

Eva Design System: Deep learning color generator is a browser-based tool for producing color palettes with a deep-learning-driven algorithm. Rather than picking colors by hand, you give it a starting color, and it generates a coordinated set of shades you can use in a design system.

What it does in practice

The core idea is consistency. In a design system, you usually need more than one version of a brand color: a light tint for backgrounds, a mid tone for buttons, a darker shade for hover or pressed states. Doing this manually is slow and error-prone. This tool automates that step by deriving a family of related colors from your input.

Typical uses:

  • Building a palette for a new app or website before writing any UI code.
  • Extending an existing brand color into a full scale of light-to-dark steps.
  • Checking whether a chosen hue holds up across many variations.

Who it is for

  • UI and product designers defining a color system.
  • Front-end developers who need a set of tokens to plug into CSS variables.
  • Small teams without a dedicated brand designer who still want a coherent palette.

Trade-offs to keep in mind

  • Generated palettes are a starting point, not a finished system. You still need to verify contrast for text and interactive elements, since automated generation does not guarantee accessibility.
  • A deep-learning approach can produce pleasant, harmonious results, but it may not match strict brand guidelines or exact corporate color values.
  • If your project depends on precise, pre-approved brand colors, treat the output as a reference rather than a final answer.

A useful next step

Pick your primary brand color, generate a palette, then test the darkest and lightest shades against real text and buttons in your design tool. Adjust manually where contrast is weak, and export the final values as design tokens so the whole team uses the same set.

How does the deep learning algorithm generate color palettes?

The tool generates palettes by applying a deep learning–powered algorithm rather than by following fixed hue-rotation rules. That means the colors are produced from a model trained on color relationships, so the output reflects learned combinations of hue, saturation and lightness instead of a single formula you set manually.

For practical use, think of it as a starting-point generator: you give it a base color (or brand color), and it returns a coordinated palette you can refine. This suits designers who need a fast first draft, and developers who want consistent UI color scales without hand-tuning every shade.

H3 What this changes in practice

  • Speed vs. control: You get plausible palettes quickly, but you may still adjust contrast and accessibility manually.
  • Consistency: Learned relationships tend to produce harmonious sets, useful for design systems with many components.
  • Predictability: Unlike rule-based generators, the exact output is harder to reason about in advance, so verify results against your brand and WCAG contrast needs.

A concrete scenario: you have a primary blue and need a full scale for buttons, alerts and backgrounds. Feed the base color into Eva Design System: Deep learning color generator, take the suggested set, then test text-on-background contrast and lock the shades that pass. If you want more deterministic control, pair the output with a rule-based tool or your own token system.

Can I export the generated color palettes for use in design tools?

Yes. Eva Design System's generator is built for exactly that workflow: you produce a palette, then carry it into your design or development environment. The site's own description frames it as a color palette generator, so the export step is the natural end of the process rather than an afterthought.

What to expect when exporting

Most palette generators of this type hand you the colors in a form you can paste or import, rather than trapping them in the browser. In practice, that means you should be able to get:

  • Hex values for each swatch, so you can type them into Figma, Sketch, Adobe XD or a CSS file.
  • Copied swatches — clicking a color typically places its value on your clipboard.
  • Structured output such as CSS variables, SCSS variables or JSON, which is the most useful format if you are feeding a theme into code.

The exact set of formats is worth checking on the page itself, since generators differ: some export a full token file, others only individual hex codes.

A practical workflow

  1. Generate or adjust the palette until the ramp reads well.
  2. Export in the format closest to where it will live — CSS variables for a web project, a token file for a design system.
  3. Paste into your design tool's color styles or your codebase's theme file, then name the tokens consistently (for example primary-500, primary-600) so light and dark variants stay predictable.

If you are working inside a broader design system, Eva's own documentation is the better reference for how the generated colors are meant to be applied: Eva Design System.

When export matters less

If you only need one or two accent colors for a quick mockup, copying hex values by hand is faster than setting up a token pipeline. Export formats earn their keep when the palette has to stay in sync across design and code, or when you need to regenerate it later without re-picking every shade.

How do I create a consistent color palette for a brand or UI project?

Start by fixing a base color, then let a generator derive the rest of the scale so the hues stay related. Eva Design System: Deep learning color generator is built for exactly that: it generates palettes using a deep-learning-powered algorithm, which is useful when you want a coherent set of shades rather than hand-picking every value.

H3 Build the palette in layers

  1. Pick one anchor color. This is your brand's most recognizable hue. Everything else is derived from or checked against it.
  2. Generate a scale around it. A generator gives you lighter and darker variants of the same hue, so you get a ramp instead of isolated swatches.
  3. Assign roles, not just colors. Decide which value is the default, which is for hover, which is for disabled, which is for backgrounds. Roles are what keep a UI consistent.
  4. Add one or two accents. Use a contrasting hue for states like success, warning or error, and keep those separate from your brand ramp.
  5. Test in context. Put the palette on real screens with real text before you commit.

H3 What a generator helps with, and what it doesn't

A tool like Eva is strong at producing a harmonious starting set quickly, especially when you need many steps of one hue. It does not know your brand's meaning, your accessibility requirements or how the palette behaves on dark backgrounds. Treat its output as a draft, then adjust.

H3 A quick comparison of approaches

Approach Best for Trade-off
Single anchor + generated ramp UI systems needing many shades Needs manual contrast checks
Hand-picked swatches Small brand palettes Slow to extend, easy to drift
Fixed framework palette Fast prototypes Less distinctive

H3 Practical check before you ship

  • Contrast: body text should be clearly readable against its background; check your key pairs.
  • Consistency: the same role should always use the same value across screens.
  • Dark mode: don't just invert; define a separate set of values for dark surfaces.
  • Naming: name by role (primary, primary-hover) rather than by appearance (blue-500), so the palette survives a rebrand.

If you want a concrete next step, take your brand's main color, run it through Eva Design System: Deep learning color generator to get a full ramp, then assign each step to a UI role and verify text contrast on your three most common screens.

What are the best practices for applying the generated colors in web or mobile design?

A generated palette is only a starting point, not a finished design system. The practical goal is to assign each color a stable job, then test that assignment against real content and accessibility constraints before you commit to it.

Give every color a role. Most generated palettes read best when you define a small set of semantic tokens rather than using raw swatches directly:

  • Primary / brand: main actions, active states, key highlights.
  • Secondary / accent: supporting emphasis, badges, secondary buttons.
  • Surface: page and card backgrounds, often a near-neutral tint of the brand hue.
  • Text: primary and secondary text colors, checked for contrast on each surface.
  • Semantic: success, warning, error, info — usually not taken straight from the brand palette.
  • Border / divider: low-emphasis separators.

Name tokens by role (color-action-primary) rather than by hue (blue-500), so you can swap the palette later without rewriting component code.

Check contrast before aesthetics. Text and meaningful icons should be tested against every surface they appear on, not just the default background. Body text on a tinted surface often fails even when it passes on white. Interactive elements also need a visible non-color cue — underline, icon or shape — because color alone excludes some users.

Build a ramp, not a single swatch. A generator gives you a set of colors; interfaces usually need light and dark variants of each. Create a few steps per role (subtle, default, strong) so hover, pressed and disabled states have somewhere to go. If you cannot produce a coherent dark theme by shifting lightness and desaturating, the palette is probably too saturated to begin with.

Test in context. Drop the palette into a realistic screen — a form with validation errors, a data table, a notification banner — rather than judging swatches on a white canvas. Real UI exposes clashes between semantic colors and the brand hue, which is a common failure when the primary color sits close to red or green.

Keep the generated palette as one source, not the source. Tools such as Eva Design System: Deep learning color generator are useful for producing an initial harmonious set quickly, but the durable artifact is your token file and its documented contrast rules. Store the palette alongside usage notes so future contributors know which colors are interchangeable and which are reserved.

A useful next step: pick your three most common screens, apply the roles above, and run a contrast check on every text/surface pair. If more than a couple of pairs fail, adjust the tokens — not the individual components.

Is Eva Design System free to use, and are there any licensing restrictions?

Eva Design System's color generator is a free browser-based tool: you open the page, enter a base color or brand color, and it produces a full palette with shades and semantic variants. There is no visible pricing or checkout flow on the tool page, so for the generator itself you can treat it as free to use without a signup step.

Where the licensing question actually applies

The generator and the design system are two different things, and the licensing answer differs:

  • The web generator at Eva Design System: Deep learning color generator is a utility you use in the browser to derive palettes. Nothing on the page indicates a fee, account, or paid tier for generating colors.
  • The Eva Design System itself is an open-source project (published by Akveo) with its own repository and license file. If you plan to copy its component code, theme structure, or Figma libraries into a product, check that repository's license text rather than the generator page — that is where the binding terms live.
  • Generated palettes are color values, not copyrightable works in most jurisdictions. Using a palette you generated in your own app, brand, or client project is normal practice; a specific color combination is generally not something a tool can restrict.

Practical guidance

If you are a solo developer or a small team picking brand colors, the safe path is: generate the palette, then document the base color and the steps you used so you can regenerate or adjust it later. If you are embedding Eva's actual components or theme tokens into a commercial product, open the project's license file and confirm whether attribution or copyleft obligations apply to your distribution model.

For a quick sanity check on any design tool's terms, look for a linked "License," "Terms," or GitHub repository in the page footer — the absence of a pricing page is a good sign, but it is not the same as an explicit license grant.

Related questions

More questions →
How Is Eva Design System's Color Generator Different From Typical Palette Tools?

Eva Design System's color generator is different because it uses a deep learning powered algorithm to generate palettes, rather than relying on manual color picking or fixed rule-based formulas. According to the site, the tool is built specifically to "generate color pallets using deep learning powered algorithm." That single design choice changes what the tool is, how you interact with it, and what kind of output you get. If you only need a quick set of swatches, a typical palette tool may be enough. If you want palettes produced by a trained model rather than by hand or by preset rules, this tool is aimed at that use case.

The core difference: algorithm-driven generation

Typical color palette tools usually fall into two categories:

  • Manual pickers — you choose each color yourself, often with a color wheel or hex input.
  • Rule-based generators — the tool applies fixed formulas such as complementary, analogous, or triadic relationships to produce a palette.

Eva Design System's generator is described as using a deep learning powered algorithm. That means the palette is not simply the result of a rule you selected or colors you entered one by one. The algorithm itself is the mechanism that produces the palette. This is the defining difference the site states, and it is the main reason the tool is categorized separately from conventional palette generators.

What this changes for you

Dimension Typical palette tools Eva Design System generator
Generation method Manual selection or fixed color rules Deep learning powered algorithm
Your main input Picking colors or choosing a harmony rule Relying on the algorithm to generate the palette
Basis of harmony Predefined color theory rules Algorithm-driven output
Positioning General-purpose color utility Deep learning color generator

The practical benefit the site points to is algorithm-driven color harmony: instead of you deciding which colors work together through manual choice or a preset rule, the deep learning model handles the generation. The site does not claim specific accuracy, speed, or aesthetic guarantees beyond describing the algorithm as deep learning powered, so those claims should not be assumed.

When this difference matters

Choose a deep-learning-based generator like this one when:

  • You want palettes produced by a model rather than by manually selecting swatches.
  • You are specifically interested in how a deep learning algorithm approaches color generation.
  • You want to move away from rule-based harmony systems and see what an algorithm-driven approach produces.

A typical manual or rule-based tool may be a better fit when:

  • You already know the exact colors you want and just need to enter them.
  • You want full control over each swatch and the relationships between them.
  • You prefer predictable, rule-based harmony (complementary, analogous, etc.) over algorithm-generated results.

How to evaluate the difference yourself

  1. Open colors.eva.design.
  2. Generate a palette using the tool.
  3. Compare the result with what a rule-based generator would produce from the same starting point.
  4. Note whether the palette reflects a fixed color-theory rule or an algorithm-driven selection.

The expected result is a palette that comes from the deep learning algorithm rather than from a rule you chose. The key thing to verify is whether the generation feels algorithm-driven rather than rule-driven — that is the distinction the site is built around.

Common points of confusion

  • "Deep learning" does not automatically mean better colors. The site describes the method, not a quality guarantee. Treat the algorithm as the differentiator, not as proof of superior output.
  • It is still a palette generator. The deep learning aspect changes how palettes are produced, not what a palette is.
  • The difference is in generation, not in editing. The site's stated focus is generating palettes with a deep learning algorithm, so do not assume manual editing features that are not described.

The clearest way to understand the difference is to use the tool and compare its output with a manual or rule-based generator. The deep learning powered algorithm is the feature that separates it from typical palette tools, and that is the basis on which the site presents it.

What Can I Use the Color Palettes from Eva Design System For?

Eva Design System's color generator (colors.eva.design) produces palettes using a deep learning powered algorithm, and the practical answer is: use them as a starting point for interface and product design work — UI themes, component states, and design-token style color scales. They are best treated as a draft palette you refine, not a finished brand identity. The site describes itself only as a generator of color palettes via deep learning, so anything beyond palette generation (export formats, code integrations, brand guidelines) is not confirmed by the source and should be verified on the site itself.

Where these palettes fit best

UI and product design

This is the most natural fit, because the generator comes out of the Eva Design System context — a system built around application UI. A generated palette gives you a coherent set of related colors you can map onto:

  • Primary, success, info, warning, and danger roles
  • Background and surface layers
  • Text at different emphasis levels
  • Interactive states such as hover, active, and disabled

Web and app theming

If you need a quick, internally consistent color scheme before committing to a design system, a generated palette is a reasonable placeholder. It lets you build and test layouts with realistic color relationships instead of gray boxes.

Branding exploration (with caution)

You can use a palette as early visual exploration — moodboards, concept directions, client options. But a deep-learning generator optimizes for palette harmony, not for your brand's meaning, market position, or accessibility requirements. Treat output as a candidate, then adjust.

What makes a generated palette usable

A palette is only useful if the colors relate to each other in a structured way. When evaluating output from colors.eva.design, check:

Check Why it matters
Contrast between text and background Readability in real UI
Distinguishability of semantic colors Users must tell success from error at a glance
Light-to-dark range within one hue Needed for hover, borders, and disabled states
Consistency across hues Prevents one color looking out of place

If a generated set fails these, adjust the specific colors rather than regenerating endlessly — the algorithm gives you a structure, and you supply the constraints.

How to move from palette to project

  1. Generate a palette on colors.eva.design.
  2. Assign roles: pick which color is primary, which are semantic, which are neutrals.
  3. Test in context — place the colors in an actual screen or page, not just swatches.
  4. Check contrast for text and key controls.
  5. Adjust and document the final values in whatever format your project uses.

The generator's job ends at step 1. Steps 2–5 are where the palette becomes usable, and they depend on your project's requirements, not on the tool.

Limits to keep in mind

  • The source material confirms only that palettes are generated by a deep learning algorithm. It does not confirm export formats, framework integrations, or design-tool plugins — check the site for current capabilities.
  • No pricing or account requirements are stated in the available information, so do not assume the tool is free or login-free.
  • A generated palette is not an accessibility guarantee. Contrast and color-blindness checks are your responsibility.

Used this way — as a structured starting point for UI, web, and early brand exploration — the palettes from Eva Design System save time on color relationships while leaving the design decisions where they belong: with you.

How Does the Deep Learning Algorithm Generate Color Palettes on colors.eva.design?

Eva Design System's color generator uses a deep learning powered algorithm to turn a single base color into a full palette of harmonious shades. You provide the starting color, and the tool returns a set of related colors intended to work together as a design system palette. The site describes the mechanism at a high level only: it is a "deep learning powered algorithm" for generating color palettes. It does not publish the model architecture, training data, or the exact math behind each shade, so the explanation below stays at the level the site supports.

What the tool does

The generator's job is to expand one color into a usable set. In design systems, a single brand color usually isn't enough — you need lighter and darker variants for backgrounds, borders, hover states, text, and disabled states. The deep learning approach is meant to produce those variants as a coherent family rather than as arbitrary tints and shades.

The site's own description is short and specific: "Generate color pallets using deep learning powered algorithm." That is the core claim. Everything else about how the model works internally is not stated on the page.

How a base color becomes a palette

At the level the site describes, the flow is:

  1. You supply a base color. This is the seed — typically a brand or primary color you already want to build around.
  2. The algorithm processes it. A deep learning model, rather than a fixed formula like simple lightness steps, determines the resulting shades.
  3. A palette is returned. The output is a set of colors derived from the input, positioned as a harmonious group.

The important distinction is between a rule-based generator and a learned one. A rule-based tool might just add fixed percentages of white or black. A deep learning model is trained to recognize what "goes together" and can produce combinations that a simple formula would miss. The site frames its output as harmonious color combinations, which is the practical benefit of using a learned model instead of manual mixing.

Why "harmonious" matters

Harmony here means the generated colors are meant to be used together without clashing — for example, a set of shades where the lighter and darker steps stay visually related to the base rather than drifting into a different hue family. This is what makes the output usable as a design system palette: you can assign the shades to roles (primary, hover, subtle background, border) and they will read as one consistent scale.

What the site does not specify

To avoid overclaiming, note what is not documented on the page:

  • The specific deep learning architecture or model type
  • The training dataset or how the model was trained
  • The exact color space or interpolation method used
  • Any numeric formula for how each shade is derived

If you need those details, they are not available from the site's own description. What you can rely on is the stated behavior: a base color in, a deep-learning-generated palette out.

Practical takeaway

Use colors.eva.design when you have a base color and want a ready-made set of related shades without hand-tuning each one. The value is speed and consistency: the algorithm handles the derivation, and you get a palette you can drop into a design system. Treat the output as a starting point — the site presents it as generated harmonious combinations, not as a guaranteed match for every accessibility or contrast requirement, so verify contrast where it matters for your use case.

How to Use the Eva Design System Color Generator to Create a Palette

Go to colors.eva.design and use the on-page generator: you provide a base color, and the tool returns a generated palette. That is the core workflow. The site describes itself as an "Eva Design System: Deep learning color generator" that will "Generate color pallets using deep learning powered algorithm," so the page is built around a single generate-from-input interaction rather than a multi-step wizard.

What the tool is

Eva Design System's color generator is a browser-based utility hosted at colors.eva.design. Its stated purpose is to produce color palettes using a deep-learning-powered algorithm. You do not install anything; you open the page and work in it.

Basic steps

  1. Open colors.eva.design in your browser.
  2. Locate the generator controls on the page — the interface is centered on producing a palette from your input.
  3. Enter the color you want to build from (the base color the palette will be derived from).
  4. Trigger generation and read the resulting palette from the page output.
  5. If the page exposes adjustment controls, change them and regenerate to compare results.

The expected result at each generation is a palette derived from your input color, not a single swatch.

What to check on the page

Because the tool's visible options can change, verify these directly on the site rather than assuming:

  • Input format — whether the base color is entered as a hex value, picked from a color field, or both.
  • Palette display — how many shades or steps are shown and whether each swatch exposes a copyable value.
  • Adjustment options — any sliders, toggles, or presets that alter the generated output.
  • Export or copy actions — whether you can copy individual colors or the full palette for use in design or code.

Practical notes

  • Treat the first generated palette as a starting point; regenerate after changing the base color to see how the algorithm responds.
  • If you need the palette in a specific format (CSS variables, design-token names), check whether the page offers that output before copying values manually.
  • The page's own description does not state pricing or login requirements, so confirm on the site whether any features are gated.

Quick reference

Step Action Expected result
1 Open colors.eva.design Generator page loads
2 Enter a base color Input is registered
3 Generate A palette derived from the base color appears
4 Adjust options (if present) Palette updates to reflect changes
5 Copy or export Palette values available for use

If your goal is simply to get a usable palette fast, steps 1–3 are enough. The remaining steps matter when you need the output to match a specific format or design system.

What is Eva Design System's Deep Learning Color Generator?

Eva Design System's Deep Learning Color Generator (colors.eva.design) is a web tool that generates color palettes using a deep learning powered algorithm. It belongs to the Eva Design System, an open-source UI framework, and its core purpose is to produce ready-to-use color palettes rather than to serve as a general-purpose color picker or a full design application.

What the tool does

The site's stated function is narrow and specific: generate color palettes using a deep learning powered algorithm. That means you supply a starting point, and the tool returns a coordinated set of colors derived from it.

Typical uses for a generated palette include:

  • Building a consistent color scheme for a UI or product
  • Deriving lighter and darker shades from a base brand color
  • Producing a palette that stays visually coherent across multiple steps

Why it is tied to the Eva Design System

The generator is part of the Eva Design System, which is why its output is oriented toward interface design rather than illustration or print. Design systems generally need colors organized into usable ranges — a base tone plus variations — so that components, states, and themes stay consistent. A generator that produces a full palette in one step fits that need better than picking colors one at a time.

How to think about "deep learning powered"

The description states the algorithm is deep learning powered. In practice, this means the palette is produced by a trained model rather than by a fixed formula such as simple lightness scaling. For you as a user, the relevant consequence is that the generated palette reflects patterns learned from color relationships, not just a mechanical adjustment of one input value.

When to use it — and when not to

Situation Is this tool a good fit?
You need a coordinated palette from a base color Yes — that is its stated purpose
You are working within or alongside the Eva Design System Yes — it is part of that system
You want a single color converted to a specific format Not its focus
You need print color management or ICC profiles Not indicated by the site

What to check before relying on it

The available site information covers what the tool is and what it does, but does not include details on pricing, account requirements, export formats, or licensing of generated palettes. If any of those matter for your project, verify them directly on the site before building them into a workflow.

Website Overview

An established domain and managed infrastructure suggest continuity of operations and may support dependable delivery, although neither guarantees service quality. Several search or sharing settings need attention. Together they may make snippets, preview images or preferred URLs less consistent across platforms.

Domain and Registration

Registered in 2019, this domain has about 7 years of history. That suggests continuity, although ownership and purpose may have changed. Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The registrar is Squarespace Domains II LLC, a widely used domain service provider. Registration contact information is publicly available through RDAP. The domain uses the common .design extension, which is not an independent safety signal.

DNS and Email

MX records exist, but SPF, DKIM and DMARC were not detected. Protection against domain impersonation may be incomplete. Nameservers are provided by Cloudflare, indicating managed DNS hosting. MX records point to the Google Workspace email service. No CNAME was found; the observed records resolve directly to addresses. TXT records include verification markers for Google, Microsoft. Such markers may also remain after a service stops being used.

TLS and Certificates

The public key uses EC with 256 bits. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued within the Google Trust Services cloud or CDN ecosystem. The certificate's total validity is about 90 days, consistent with a short renewal cycle.

HTTP and Browser Security

The checked browser-security headers were not detected, leaving fewer explicit browser-side safeguards. No X-Powered-By header was found, reducing one common source of backend fingerprinting information. The cf-ray response header indicates a CDN or caching proxy in the delivery path. No obvious internal addresses or debug information were found in the headers. The Server header identifies cloudflare without an exact version.

Technology Stack Analysis

The public page identifies Google Tag Manager, Cloudflare without precise versions, leaving fewer clues for version-specific scanning.

Search and Social Sharing

No homepage canonical URL was detected. If duplicate URLs exist, consolidation may be less explicit. No Open Graph metadata was detected, so social previews may depend on platform inference. The title has 48 characters, within a common display range. A meta description is present, with 60 characters. The observed directives allow indexing and link following.

Hosting and Email

DNSCloudflare
HostingCloudflare
EmailGoogle Workspace
Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) Location unknown Inferred 104.21.71.57

Registration details

RDAP / WHOIS

RegistrarSquarespace Domains II LLC
Registered2019-02-06
Expires2027-02-06
Domain statusclient transfer prohibited、client delete prohibited
Nameserversbart.ns.cloudflare.com、melinda.ns.cloudflare.com
DNSSECunsigned

DNS records

DNS

TypeNameValueTTLPriority
Acolors.eva.design104.21.71.57300—
Acolors.eva.design172.67.169.249300—
AAAAcolors.eva.design2606:4700:3030::6815:4739300—
AAAAcolors.eva.design2606:4700:3037::ac43:a9f9300—
MXeva.designaspmx.l.google.com864001
MXeva.designalt1.aspmx.l.google.com864005
MXeva.designalt2.aspmx.l.google.com864005
MXeva.designaspmx2.googlemail.com8640010
MXeva.designaspmx3.googlemail.com8640010
NSeva.designbart.ns.cloudflare.com86400—
NSeva.designmelinda.ns.cloudflare.com86400—
TXTeva.designMS=ms98052539300—
TXTeva.designgoogle-site-verification=sq4LslWQZxL5XjRcKb3POw4AyfJ3M5vAWmRnRdluk24300—

TLS and certificates

TLS / SSL

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subjecteva.design
IssuerGoogle Trust Services
Valid until2026-11-06T13:01 · Remaining when checked: 35 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

HeaderValue
content-typetext/html
servercloudflare

Identified technologies

Google Tag ManagerCloudflare

Pages, Search and Sharing

Meta descriptionGenerate color pallets using deep learning powered algorithm
Canonical URLNot detected
LanguageEnglish (default)
Twitter CardNot detected

Unknown

No rules found

No sitemaps found

User reviews (0)

  • No reviews yet.