Elegante Ringe mit ausgewählten Farbsteinen

Die Ring Kollektion entdecken

Puristischer Ohrschmuck

Den Ohrschmuck entdecken

Diana Faraj

Schmuckdesignerin
und Goldschmiedemeisterin

Mehr im Portrait erfahren

In einer persönlichen Beratung mehr
zur Kollektion erfahren

Einen Beratungstermin vereinbaren

Klassische Eleganz in Rotgold und Aquamarin

Die Ring Kollektion entdecken

Die elegante Schmuck Kollektion
aus Düsseldorf entdecken

Aus Rot und Weißgold kreiert Diana Faraj
eine elegante wie zeitlose Schmuck Kollektion,
meisterlich gefertigt mit ausgewählten Edelsteinen
und Brillanten

Die elegante
Schmuck Kollektion
aus Düsseldorf
entdecken

Aus Rot und Weißgold
kreiert Diana Faraj
eine elegante wie zeitlose
Schmuck Kollektion,
meisterlich gefertigt mit
ausgewählten Edelsteinen
und Brillanten

Nächste Ausstellungen

Schloss Lembeck (Dorsten)

24. - 25. August 24

Schloss Wolfsgarten (Rhein-Main)

20. - 22. September 24

Düsseldorf

9. - 10. November 24

BEGIN WPACU PLUGIN JSON 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END WPACU PLUGIN JSON ENQUEUEDBEGIN WPACU PLUGIN JSON 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END WPACU PLUGIN JSON HARDCODED

Elegante Ringe mit ausgewählten Farbsteinen

Puristischer Ohrschmuck

Diana Faraj

In einer persönlichen Beratung mehr
zur Kollektion erfahren

Klassische Eleganz in Rotgold und Aquamarin

Die elegante Schmuck Kollektion
aus Düsseldorf entdecken

Aus Rot und Weißgold kreiert Diana Faraj
eine elegante wie zeitlose Schmuck Kollektion,
meisterlich gefertigt mit ausgewählten Edelsteinen
und Brillanten

Die elegante
Schmuck Kollektion
aus Düsseldorf
entdecken

Aus Rot und Weißgold
kreiert Diana Faraj
eine elegante wie zeitlose
Schmuck Kollektion,
meisterlich gefertigt mit
ausgewählten Edelsteinen
und Brillanten

Schloss Lembeck (Dorsten)

Schloss Wolfsgarten (Rhein-Main)

Düsseldorf

Datenschutzhinweis

Ringe ‧ Ohrschmuck ‧ Portrait ‧ Ausstellungen ‧ Beratung ‧ Impressum ‧ Datenschutzerklärung

© Diana Faraj Schmuck ‧ Made with in Düsseldorf

Datenschutzhinweis

Elegante Ringe mit ausgewählten Farbsteinen

Puristischer Ohrschmuck

Diana Faraj

In einer persönlichen Beratung mehrzur Kollektion erfahren

Klassische Eleganz in Rotgold und Aquamarin

Die elegante Schmuck Kollektion aus Düsseldorf entdecken

Aus Rot und Weißgold kreiert Diana Faraj eine elegante wie zeitlose Schmuck Kollektion, meisterlich gefertigt mit ausgewählten Edelsteinen und Brillanten

Die elegante Schmuck Kollektion aus Düsseldorf entdecken

Aus Rot und Weißgold kreiert Diana Faraj eine elegante wie zeitlose Schmuck Kollektion, meisterlich gefertigt mit ausgewählten Edelsteinen und Brillanten

Schloss Lembeck (Dorsten)

Schloss Wolfsgarten (Rhein-Main)

Düsseldorf

Datenschutzhinweis

Ringe ‧ Ohrschmuck ‧ Portrait ‧ Ausstellungen ‧ Beratung ‧ Impressum ‧ Datenschutzerklärung

© Diana Faraj Schmuck ‧ Made with in Düsseldorf

Datenschutzhinweis

In einer persönlichen Beratung mehr
zur Kollektion erfahren

Die elegante Schmuck Kollektion
aus Düsseldorf entdecken

Aus Rot und Weißgold kreiert Diana Faraj
eine elegante wie zeitlose Schmuck Kollektion,
meisterlich gefertigt mit ausgewählten Edelsteinen
und Brillanten

Die elegante
Schmuck Kollektion
aus Düsseldorf
entdecken

Aus Rot und Weißgold
kreiert Diana Faraj
eine elegante wie zeitlose
Schmuck Kollektion,
meisterlich gefertigt mit
ausgewählten Edelsteinen
und Brillanten