diff --git a/src/serra/add.go b/src/serra/add.go
index 42b6906..9726c8e 100644
--- a/src/serra/add.go
+++ b/src/serra/add.go
@@ -88,8 +88,16 @@ func addCards(cards []string, unique bool, count int64) error {
 
 	// Loop over different cards
 	for _, card := range cards {
+		// Extract collector number and set name from card input & trim any leading 0 from collector number
+		collectorNumber := strings.TrimLeft(strings.Split(card, "/")[1], "0")
+		setName := strings.Split(card, "/")[0]
+
 		// Check if card is already in collection
-		co, _ := coll.storageFind(bson.D{{"set", strings.Split(card, "/")[0]}, {"collectornumber", strings.Split(card, "/")[1]}}, bson.D{})
+		co, err := coll.storageFind(bson.D{{"set", setName}, {"collectornumber", collectorNumber}}, bson.D{})
+		if err != nil {
+			LogMessage(fmt.Sprintf("%v", err), "red")
+			continue
+		}
 
 		if len(co) >= 1 {
 			c := co[0]
@@ -113,7 +121,7 @@ func addCards(cards []string, unique bool, count int64) error {
 			// If card is not already in collection, fetching from scyfall
 		} else {
 			// Fetch card from scryfall
-			c, err := fetchCard(card)
+			c, err := fetchCard(setName, collectorNumber)
 			if err != nil {
 				LogMessage(fmt.Sprintf("%v", err), "red")
 				continue
diff --git a/src/serra/missing.go b/src/serra/missing.go
index 0f41d60..62c1c22 100644
--- a/src/serra/missing.go
+++ b/src/serra/missing.go
@@ -20,44 +20,46 @@ var missingCmd = &cobra.Command{
 	Long: `In case you are a set collector, you can generate a list of
 cards you dont own (yet) :)`,
 	SilenceErrors: true,
-	RunE: func(cmd *cobra.Command, setname []string) error {
+	RunE: func(cmd *cobra.Command, setName []string) error {
 		client := storageConnect()
 		coll := &Collection{client.Database("serra").Collection("cards")}
 		defer storageDisconnect(client)
 
 		// fetch all cards in set
-		cards, err := coll.storageFind(bson.D{{"set", setname[0]}}, bson.D{{"collectornumber", 1}})
+		cards, err := coll.storageFind(bson.D{{"set", setName[0]}}, bson.D{{"collectornumber", 1}})
 		if (err != nil) || len(cards) == 0 {
-			LogMessage(fmt.Sprintf("Error: Set %s not found or no card in your collection.", setname[0]), "red")
+			LogMessage(fmt.Sprintf("Error: Set %s not found or no card in your collection.", setName[0]), "red")
 			return err
 		}
 
 		// fetch set informations
 		setcoll := &Collection{client.Database("serra").Collection("sets")}
-		sets, _ := setcoll.storageFindSet(bson.D{{"code", setname[0]}}, bson.D{{"_id", 1}})
+		sets, _ := setcoll.storageFindSet(bson.D{{"code", setName[0]}}, bson.D{{"_id", 1}})
 		set := sets[0]
 
 		LogMessage(fmt.Sprintf("Missing cards in %s", sets[0].Name), "green")
 
 		// generate set with all setnumbers
-		var complete_set []string
-		var i int64
+		var (
+			completeSet []string
+			i           int64
+		)
 		for i = 1; i <= set.CardCount; i++ {
-			complete_set = append(complete_set, strconv.FormatInt(i, 10))
+			completeSet = append(completeSet, strconv.FormatInt(i, 10))
 		}
 
 		// iterate over all cards in collection
-		var in_collection []string
+		var inCollection []string
 		for _, c := range cards {
-			in_collection = append(in_collection, c.CollectorNumber)
+			inCollection = append(inCollection, c.CollectorNumber)
 		}
 
-		misses := missing(in_collection, complete_set)
+		misses := missing(inCollection, completeSet)
 
 		// Fetch all missing cards
 		missingCards := []*Card{}
 		for _, m := range misses {
-			card, err := fetchCard(fmt.Sprintf("%s/%s", setname[0], m))
+			card, err := fetchCard(setName[0], m)
 			if err != nil {
 				continue
 			}
diff --git a/src/serra/remove.go b/src/serra/remove.go
index 54f97cf..a70a97e 100644
--- a/src/serra/remove.go
+++ b/src/serra/remove.go
@@ -36,7 +36,6 @@ var removeCmd = &cobra.Command{
 }
 
 func removeCardsInteractive(unique bool, set string) {
-
 	if len(set) == 0 {
 		LogMessage("Error: --set must be given in interactive mode", "red")
 		os.Exit(1)
@@ -64,15 +63,19 @@ func removeCardsInteractive(unique bool, set string) {
 }
 
 func removeCards(cards []string, count int64) error {
-
+	// Connect to the DB & load the collection
 	client := storageConnect()
 	coll := &Collection{client.Database("serra").Collection("cards")}
 	defer storageDisconnect(client)
 
 	// Loop over different cards
 	for _, card := range cards {
+		// Extract collector number and set name from input & remove leading zeros
+		collectorNumber := strings.TrimLeft(strings.Split(card, "/")[1], "0")
+		setName := strings.Split(card, "/")[0]
+
 		// Fetch card from scryfall
-		c, err := findCardbyCollectornumber(coll, strings.Split(card, "/")[0], strings.Split(card, "/")[1])
+		c, err := findCardbyCollectornumber(coll, setName, collectorNumber)
 		if err != nil {
 			LogMessage(fmt.Sprintf("%v", err), "red")
 			continue
@@ -94,7 +97,7 @@ func removeCards(cards []string, count int64) error {
 		} else {
 			modifyCardCount(coll, c, -1, foil)
 		}
-
 	}
+
 	return nil
 }
diff --git a/src/serra/scryfall.go b/src/serra/scryfall.go
index a3cb66f..00af308 100644
--- a/src/serra/scryfall.go
+++ b/src/serra/scryfall.go
@@ -7,7 +7,6 @@ import (
 	"io/ioutil"
 	"log"
 	"net/http"
-	"strings"
 	"time"
 
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -169,20 +168,15 @@ type Set struct {
 	URI          string             `json:"uri"`
 }
 
-func fetchCard(path string) (*Card, error) {
-	if !strings.Contains(path, "/") {
-		return &Card{}, fmt.Errorf("Card must follow format <set>/<number>, for example: ath/15")
-	}
-
-	// TODO better URL Building...
-	resp, err := http.Get(fmt.Sprintf("https://api.scryfall.com/cards/%s/", path))
+func fetchCard(setName, collectorNumber string) (*Card, error) {
+	resp, err := http.Get(fmt.Sprintf("https://api.scryfall.com/cards/%s/%s/", setName, collectorNumber))
 	if err != nil {
 		log.Fatalln(err)
 		return &Card{}, err
 	}
 
 	if resp.StatusCode != 200 {
-		return &Card{}, fmt.Errorf("Card %s not found", path)
+		return &Card{}, fmt.Errorf("Card %s/%s not found", setName, collectorNumber)
 	}
 
 	//We Read the response body on the line below.
diff --git a/src/serra/update.go b/src/serra/update.go
index d4d64de..399bfc9 100644
--- a/src/serra/update.go
+++ b/src/serra/update.go
@@ -77,17 +77,17 @@ var updateCmd = &cobra.Command{
 			)
 			for _, card := range cards {
 				bar.Add(1)
-				updated_card, err := fetchCard(fmt.Sprintf("%s/%s", card.Set, card.CollectorNumber))
+				updatedCard, err := fetchCard(card.Set, card.CollectorNumber)
 				if err != nil {
 					LogMessage(fmt.Sprintf("%v", err), "red")
 					continue
 				}
 
-				updated_card.Prices.Date = primitive.NewDateTimeFromTime(time.Now())
+				updatedCard.Prices.Date = primitive.NewDateTimeFromTime(time.Now())
 
 				update := bson.M{
-					"$set":  bson.M{"serra_updated": primitive.NewDateTimeFromTime(time.Now()), "prices": updated_card.Prices, "collectornumber": updated_card.CollectorNumber},
-					"$push": bson.M{"serra_prices": updated_card.Prices},
+					"$set":  bson.M{"serra_updated": primitive.NewDateTimeFromTime(time.Now()), "prices": updatedCard.Prices, "collectornumber": updatedCard.CollectorNumber},
+					"$push": bson.M{"serra_prices": updatedCard.Prices},
 				}
 				coll.storageUpdate(bson.M{"_id": bson.M{"$eq": card.ID}}, update)
 			}
@@ -97,10 +97,10 @@ var updateCmd = &cobra.Command{
 
 			// calculate value summary
 			matchStage := bson.D{{"$match", bson.D{{"set", set.Code}}}}
-			setvalue, _ := coll.storageAggregate(mongo.Pipeline{matchStage, projectStage, groupStage})
+			setValue, _ := coll.storageAggregate(mongo.Pipeline{matchStage, projectStage, groupStage})
 
 			p := PriceEntry{}
-			s := setvalue[0]
+			s := setValue[0]
 
 			p.Date = primitive.NewDateTimeFromTime(time.Now())
 
@@ -108,19 +108,19 @@ var updateCmd = &cobra.Command{
 			mapstructure.Decode(s, &p)
 
 			// do the update
-			set_update := bson.M{
+			setUpdate := bson.M{
 				"$set":  bson.M{"serra_updated": p.Date},
 				"$push": bson.M{"serra_prices": p},
 			}
 			// fmt.Printf("Set %s%s%s (%s) is now worth %s%.02f EUR%s\n", Pink, set.Name, Reset, set.Code, Yellow, setvalue[0]["value"], Reset)
-			setscoll.storageUpdate(bson.M{"code": bson.M{"$eq": set.Code}}, set_update)
+			setscoll.storageUpdate(bson.M{"code": bson.M{"$eq": set.Code}}, setUpdate)
 		}
 
-		totalvalue, _ := coll.storageAggregate(mongo.Pipeline{projectStage, groupStage})
+		totalValue, _ := coll.storageAggregate(mongo.Pipeline{projectStage, groupStage})
 
 		t := PriceEntry{}
 		t.Date = primitive.NewDateTimeFromTime(time.Now())
-		mapstructure.Decode(totalvalue[0], &t)
+		mapstructure.Decode(totalValue[0], &t)
 
 		// This is here to be able to fetch currency from
 		// constructed new priceentry