How to make a door in Roblox Studio

How a scripted door works

A door that works in a live game has to be moved by the server. If a LocalScript moves it, the door opens on that one player's screen and stays shut for everyone else, because a change a client makes stays on that device (see what replicates and what does not). So in this guide the player's device only shows the prompt and reports the key press, and one server Script does everything else. One use of a door goes like this:

1. The player walks within 8 studs of the door and a prompt appears with the action Open and the object name Door, and E on a keyboard. Roblox shows the matching button on a gamepad or a touch screen.
2. The player holds E for 0.2 seconds. The prompt's Triggered event fires on the server with that player.
3. DoorService checks the player: alive, close enough, not spamming the prompt, and carrying the key if the door needs one.
4. It tweens a number from 0 (closed) to 1 (open). Each time the number changes, it moves the door that fraction of the way from its closed position to its open one with PivotTo.
5. Four seconds after the door is fully open, it closes the same way. A press while the door is moving turns it back from wherever it is.

Workspace
  FrontDoor Part new
  VaultDoor Model new
    Panel Part new
    Knob Part new
ServerScriptService
  DoorService Script new
StarterPack
  RedKey Tool new
    Handle Part new

Step 1: Build the door and set its hinge

1. In the Explorer, hover over Workspace, click the + button and insert a Part. Name it FrontDoor, set its Size to about 4, 7, 0.5 (4 studs wide, 7 tall, half a stud thick) and move it into your doorway. A door made of several parts works too: select them and press Ctrl+G to group them into a Model.
2. Tick Anchored on every part of the door and leave CanCollide on. Anchored parts never move from gravity or collisions, but a script can still move them, which is exactly what DoorService does.
3. Set the hinge. Select the door, open the Model tab and turn on Pivot. Click and hold the small arrow in the corner of the Pivot button and tick Snap, so the pivot snaps to hotspots on corners, edges and centres. Drag the pivot to the edge of the door where the hinges would be. A sliding door can keep its pivot in the centre.
4. Add the tag. With the door selected, scroll the Properties window to Tags, click + and type Door, with a capital D. For a Model door, tag the Model, not the parts inside it.
5. Build a second door, for the sliding and key sections later. Insert two more Parts in Workspace: Panel, sized about 4, 7, 0.5, and Knob, about 0.5, 0.5, 0.5, set against one face of Panel. Select both, press Ctrl+G and rename the new Model VaultDoor. Anchor both parts, move the model into a second doorway and add the Door tag to the Model. Its pivot can stay in the centre, because this door will slide.

The pivot matters because a swinging door turns around it. Left in the centre, the door spins on the spot like a revolving door. For a part, the pivot you set is saved as its PivotOffset, and GetPivot includes it, so the script turns the door around exactly the point you chose. If a Model has a PrimaryPart, the model's pivot is that part's pivot, and DoorService also puts the prompt on that part. Without a PrimaryPart, the prompt goes on the first part it finds inside the model. If you set a PrimaryPart, set it before you move the pivot: assigning one moves the model's pivot to that part's pivot, as Roblox's Pivot tools page notes.

Door settings (attributes)

Every door works with the defaults below. To change one door, select it, scroll the Properties window to Attributes, click +, enter the name, choose the type and click Save, then set the value. DoorService reads the attributes once, when it sets the door up, so change them while the game is stopped.

Step 2: Add the door script

Hover over ServerScriptService, insert a Script named DoorService and paste the code below. It runs every door in the place, however many you tag. The three settings near the top apply to all doors; the attributes from Step 1 change one door.

-- Script in ServerScriptService named DoorService.
-- Opens and closes every Part or Model tagged "Door" with a hold-E prompt.
-- The server moves the door, so every player sees the same door, and the server
-- checks the distance and the key, so nobody can open a locked door from afar.
--
-- Optional attributes on each door (set them in the Properties window):
--   Style            string  "Swing" (default) or "Slide"
--   OpenAngle        number  degrees a swinging door turns around its pivot (default 90, -179 to 179)
--   SlideDistance    number  studs a sliding door moves along its width (default: its width)
--   OpenSeconds      number  how long opening takes (default 0.6)
--   AutoCloseSeconds number  close again after this long; 0 keeps it open (default 4)
--   KeyName          string  the name of a Tool the player must have, such as "RedKey"

local CollectionService = game:GetService("CollectionService")
local TweenService = game:GetService("TweenService")

local DOOR_TAG = "Door"
local PROMPT_DISTANCE = 8 -- studs
local MIN_SECONDS_BETWEEN_USES = 0.3 -- per door, against prompt spam

local doorsSetUp: { [Instance]: boolean } = {}

local function attribute(door: Instance, name: string, default: any): any
	local value = door:GetAttribute(name)
	if value == nil or typeof(value) ~= typeof(default) then
		return default
	end
	if typeof(value) == "number" and (value ~= value or math.abs(value) == math.huge) then
		return default -- NaN or infinity typed into the Properties window
	end
	return value
end

local function hasKey(player: Player, keyName: string): boolean
	local backpack = player:FindFirstChildOfClass("Backpack")
	local character = player.Character
	local inBackpack = backpack and backpack:FindFirstChild(keyName)
	local held = character and character:FindFirstChild(keyName)
	return (inBackpack ~= nil and inBackpack:IsA("Tool")) or (held ~= nil and held:IsA("Tool"))
end

local function setUpDoor(door: Instance)
	if doorsSetUp[door] or not (door:IsA("BasePart") or door:IsA("Model")) then
		return -- already a working door, or not a part or a model
	end
	local promptPart = if door:IsA("Model") then (door.PrimaryPart or door:FindFirstChildWhichIsA("BasePart", true)) else door
	if not (promptPart and promptPart:IsA("BasePart")) then
		warn(`DoorService: {door:GetFullName()} has no part to put the prompt on`)
		return
	end

	doorsSetUp[door] = true
	door.Destroying:Connect(function()
		doorsSetUp[door] = nil
	end)
	-- A copy of a working door brings the old prompt and value with it: remove them
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- Work out the closed and open positions once, from where the door is placed now
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Slide along the door's longer flat side, its width. A Model is measured along its
		-- pivot's sides, a Part by its own Size, so keep a sliding Part's pivot unrotated
		local size = if door:IsA("Model") then door:GetExtentsSize() else (door :: BasePart).Size
		local alongX = size.X >= size.Z
		local width = if alongX then size.X else size.Z
		local direction = if alongX then Vector3.xAxis else Vector3.zAxis
		openPivot = closedPivot * CFrame.new(direction * attribute(door, "SlideDistance", width))
	else
		-- Lerp always turns the shorter way round, so a bigger angle would swing the wrong way
		local angle = math.clamp(attribute(door, "OpenAngle", 90), -179, 179)
		openPivot = closedPivot * CFrame.Angles(0, math.rad(angle), 0)
	end
	local openSeconds = math.clamp(attribute(door, "OpenSeconds", 0.6), 0.05, 10)
	local autoClose = math.max(attribute(door, "AutoCloseSeconds", 4), 0)
	local keyName = attribute(door, "KeyName", "")

	-- Tween a number from 0 (closed) to 1 (open) and move the door to match it.
	-- PivotTo moves a single part or a whole model around its pivot.
	local progress = Instance.new("NumberValue")
	progress.Name = "DoorProgress"
	progress.Parent = door
	progress.Changed:Connect(function(alpha: number)
		door:PivotTo(closedPivot:Lerp(openPivot, alpha))
	end)

	local prompt = Instance.new("ProximityPrompt")
	prompt.Name = "DoorPrompt"
	prompt.ActionText = "Open"
	prompt.ObjectText = if keyName ~= "" then `Needs {keyName}` else "Door"
	prompt.HoldDuration = 0.2
	prompt.MaxActivationDistance = PROMPT_DISTANCE
	prompt.RequiresLineOfSight = false
	prompt.Parent = promptPart

	local isOpen = false
	local lastUse = 0
	local moveCount = 0

	local function move(open: boolean)
		isOpen = open
		moveCount += 1
		door:SetAttribute("Open", open) -- other scripts can read this
		prompt.ActionText = if open then "Close" else "Open"
		-- A new tween on the same value cancels the old one, so a door can turn back halfway.
		-- Scale the time by how far it still has to go.
		local target = if open then 1 else 0
		local seconds = openSeconds * math.abs(target - progress.Value)
		TweenService:Create(progress, TweenInfo.new(seconds, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), { Value = target }):Play()

		if open and autoClose > 0 then
			local thisMove = moveCount
			task.delay(openSeconds + autoClose, function()
				if moveCount == thisMove and isOpen then
					move(false)
				end
			end)
		end
	end

	prompt.Triggered:Connect(function(player: Player)
		local now = os.clock()
		if now - lastUse < MIN_SECONDS_BETWEEN_USES then
			return
		end
		-- Roblox's security guide says prompts can be abused like remotes, so check again here
		local character = player.Character
		local humanoid = character and character:FindFirstChildOfClass("Humanoid")
		local rootPart = humanoid and humanoid.RootPart
		if not (humanoid and rootPart) or humanoid.Health <= 0 then
			return
		end
		if (rootPart.Position - promptPart.Position).Magnitude > PROMPT_DISTANCE + 6 then
			return -- too far away to have used the prompt honestly
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- locked, and this player has no key
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Every door tagged now, and any tagged later (including doors cloned in by scripts)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

Tagging every door and running them from one script is the pattern Roblox recommends: its CollectionService reference says that if you find yourself adding the same script to many objects, a script that uses CollectionService may be better. GetTagged returns the doors that exist when the script starts, and GetInstanceAddedSignal catches doors tagged or added later. The client and server scripts guide covers this way of organising a place.

Make a sliding door

Select VaultDoor, add a string attribute named Style and set it to Slide. The door then moves sideways instead of turning: by its own width, or by SlideDistance studs if you set that. To slide it the other way, use a negative distance, such as -4 for a 4-stud door. Any other door, FrontDoor included, slides the same way once it has this attribute.

DoorService measures the door's two sideways sizes, its width and its thickness, and slides along the longer one. For a Model it measures with GetExtentsSize, whose box follows the orientation of the model's pivot, so a door turned 90 degrees after you group it still slides along its width rather than its thickness. For a Part it measures the part's own Size, so leave a sliding part's pivot unrotated. Moving that pivot is fine.

• Double doors: two tagged halves side by side, both with Style Slide, and one with a negative SlideDistance so they part in the middle. For swinging double doors, put each half's pivot on its outer edge and give one half a negative OpenAngle. Each half has its own prompt and opens on its own. If the halves move into each other, move the minus sign to the other half.
• A gate that slides up: this script slides along the door's width only. To lift doors instead, set direction in the script to Vector3.yAxis (every sliding door then moves up) and give each one a SlideDistance equal to its height.
• A physics door: Roblox's moving objects tutorial moves parts along one axis with a PrismaticConstraint. Like the hinged door, that is physics, with no prompt or lock unless you script one.

Lock a door with a key

A locked door opens only for a player who has a Tool with the right name. Make the key, then tell the door its name:

1. Hover over StarterPack, click + and insert a Tool named RedKey. Insert one Part into it named Handle, the part the character holds, and make sure that part is not anchored: an anchored part in a tool pins the character in place. Untick the Tool's CanBeDropped too if players should not be able to drop the key for someone else: while it is ticked, Backspace drops an equipped tool into Workspace.
2. Select VaultDoor, add a string attribute named KeyName and set it to RedKey. The prompt's object name now reads Needs RedKey.

DoorService looks for the key in two places. A Tool sits in the player's Backpack until they equip it, and equipping moves it into their character, so the door opens whether the key is in the hotbar or in their hand. The check runs on the server because Roblox's security guide names this exact case, "Do they have a key required to open a door?", as a permission the server must verify. Only opening needs the key: anyone can close an open door, and it closes on its own after AutoCloseSeconds.

StarterPack gives the key to everyone on every spawn, which is right for testing. In a real game, hand it out instead:

• From a shop: the shop GUI guide gives Tools from ServerStorage to the buyer's Backpack and StarterGear.
• From a character: the NPC dialogue guide gives a Tool from ServerStorage.DialogueItems when the player picks a choice with the GiveItem action. Put a Tool named RedKey in that folder and give a choice in DialogueData action = "GiveItem" and item = "RedKey", and the key comes from a conversation.
• As an inventory item: with the inventory system, a key item works once the player equips it, because equipping puts a copy of its Tool in their Backpack and hand.

A key in the Backpack is lost when the character dies, because Roblox refills the Backpack from StarterPack and StarterGear on every spawn. To keep it, also put a copy in the player's StarterGear, as the shop guide does. To use a key up instead, find the key Tool in the player's Backpack or character and destroy it in the Triggered handler, right after the key check passes.

What older door tutorials get wrong

If you are comparing this guide with a video or a forum post, these are the patterns that cause most "my door does not work" threads, and what this guide does instead.

What a cheater can and cannot do

Assume a cheater controls everything on their own device, including their character. Here is what that means for these doors.

Step 3: Test it

1. Press Play (F5). Walk up to FrontDoor: within 8 studs, a prompt appears with the action Open and the object name Door. Hold E. After 0.2 seconds the door swings 90 degrees around its hinge edge in 0.6 seconds, and the prompt now says Close.
2. Walk through and wait. Four seconds after it finished opening, the door closes on its own. Hold E while it is closing: it turns back and opens from where it was.
3. Test the lock. If RedKey is in StarterPack, move it to ServerStorage for now, press Play and hold E at VaultDoor: the prompt says Needs RedKey and nothing moves. Stop, put RedKey back in StarterPack and play again: VaultDoor opens, with the key in your hotbar or in your hand.
4. Check the slide. VaultDoor, a Model with Style Slide, moves sideways by its own width when it opens. Stop, select VaultDoor, rotate it 90 degrees with the Rotate tool and play again: it should still slide along its width, not its thickness. Rotate it back when you are done.
5. Choose Server & Clients in the test mode dropdown, set 2 clients and press Play. Open a door in one client window: it is open in the other window too, and it closes in both.
6. Stop the game, select a door and press Ctrl+D to duplicate it, then move the copy to another doorway. Check that the copy still lists Door under Tags, then press Play: the copy works with no extra script.

Keep the Output window open (Window menu, then Output). DoorService prints nothing when it works. A warning that a door "has no part to put the prompt on" means a tagged Model has no parts inside it. See Common errors for the rest.

Extending it

Automatic doors

For a door that opens when someone walks up, call move(true) from inside setUpDoor instead of waiting for the prompt. At the end of setUpDoor, start a loop with task.spawn, because a plain loop there never finishes and DoorService would never get past the first door. Keep it running only while the door is in the game: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). Inside the loop, check with workspace:GetPartBoundsInBox whether a character is inside a box around the doorway, and call move(true) when one is and the door is shut. Auto close then shuts it as before. Set the prompt's Enabled to false if the door should only open by itself.

VIP doors

The game pass guide already builds a VIP door that pass owners walk straight through, using collision groups. For a VIP door that opens with E instead, add one more check in the Triggered handler, next to the key check: return unless player:GetAttribute("OwnsPass_VIP") == true, the attribute the game pass guide's server script sets. Read it on the server only.

A code keypad

For a door that opens with a typed code, keep the code in a server Script or in ServerStorage, which players never receive, and never in a LocalScript, where a cheater can read it. The keypad's LocalScript sends only the typed digits through a RemoteEvent. On the server, check that the player is near the door, limit how often they can guess, compare the digits, and only then call move(true). The RemoteEvents guide shows how to check what a remote receives.

Sounds

Put a Sound inside the door's part, so it plays from that part's position, and call its Play method at the start of move. Or play it from a LocalScript that listens to the door's Open attribute with GetAttributeChangedSignal("Open"), since the server sets that attribute on every move.

Doors added while the game runs

Clone new doors from a closed template in ServerStorage. DoorService reads a door's closed position when the door appears, so a copy of a door that was open at the time would treat its open position as closed. Move the copy into its doorway with PivotTo before you set its Parent to Workspace, so DoorService records that spot as closed. Old prompts and values that come with a copy are removed automatically. For a door that takes players to another area or another place, see the teleporter guide.

Common errors and fixes

Open the Output window (Window menu, then Output) before you press Play. Most door problems come from a tag, a pivot or an attribute that is not quite what the script expects.

Build it with RoCode

If you would rather not set this up by hand, RoCode can build it in the place you have open. RoCode is an independent AI agent for Roblox Studio, not made by Roblox: you describe the change in a web chat, and its Studio plugin creates the scripts and instances in your Explorer, so there is no code to paste.

Check each door's pivot with Studio's Pivot tool before you test: the door turns around it. With plugin 3.9 or newer RoCode can run a short playtest and read the errors, but it does not move a character or press keys, so walk up to each door and hold E yourself. How RoCode connects to Studio.

Questions

Sources and further reading

• Roblox Creator Docs: PVInstance:PivotTo. moving a part or a whole model by its pivot
• Roblox Creator Docs: Pivot tools. moving the pivot, Snap and hotspots, and pivots with a PrimaryPart
• Roblox Creator Docs: Model. WorldPivot, GetExtentsSize following the pivot, and SetPrimaryPartCFrame being superseded
• Roblox Creator Docs: CFrame:Lerp. rotation interpolated along the shortest arc
• Roblox Creator Docs: TweenService. what can be tweened, and a second tween on the same property cancelling the first
• Roblox Creator Docs: Proximity prompts. creating and customising prompts, inputs for every device, and line of sight
• Roblox Creator Docs: ProximityPrompt. default key and button, HoldDuration, MaxActivationDistance and Triggered
• Roblox Creator Docs: CollectionService. tags, GetTagged and GetInstanceAddedSignal
• Roblox Creator Docs: Properties window. adding tags and attributes in Studio
• Roblox Creator Docs: Securing the client-server boundary. ProximityPrompts as an attack surface, and the key-and-door permission check
• Roblox Creator Docs: Network ownership, movement validation, and physics. what a client can do with its own character
• Roblox Creator Docs: Build a hinged door. the no-code HingeConstraint door
• Roblox Creator Docs: In-game tools. the Handle, anchoring and StarterPack
• Roblox Creator Docs: Tool.CanBeDropped. what Backspace does to an equipped tool

How the code was checked: every script on this page passes Luau's strict type checker against Roblox's API definitions (luau-lsp, 15 October 2026). A type check catches misspelt APIs and wrong types, not game logic, so playtest in Studio before you publish.